react-native-reanimated 2.10.0 → 2.12.0

package/android/build.gradle

@@ -1,11 +1,7 @@
 import com.android.Version
-
-import java.nio.file.Files
-import java.nio.file.Paths
-import java.nio.file.Path
 import org.apache.tools.ant.filters.ReplaceTokens
 import groovy.json.JsonSlurper
-import java.util.stream.Stream
+import java.nio.file.Paths
 
 /**
  * Finds the path of the installed npm package with the given name using Node's
@@ -46,14 +42,19 @@ def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
+def safeAppExtGet(prop, fallback) {
+    if (findProject(':app') == null) {
+        return fallback
+    }
+    def appProject = project(':app')
+    appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
+}
+
 def resolveBuildType() {
-    def buildType = "debug"
-    tasks.all({ task ->
-        if (task.name == "buildCMakeRelease") {
-            buildType = "release"
-        }
-    })
-    return buildType
+    Gradle gradle = getGradle()
+    String tskReqStr = gradle.getStartParameter().getTaskRequests()['args'].toString()
+    
+    return tskReqStr.contains('Release') ? 'release' : 'debug'
 }
 
 def resolveClientSideBuild() {
@@ -75,7 +76,7 @@ def resolveClientSideBuild() {
 
 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() {
@@ -87,10 +88,32 @@ def isNewArchitectureEnabled() {
 }
 
 def resolveReactNativeDirectory() {
+    def reactNativeLocation = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+    if (reactNativeLocation != null) {
+        return file(reactNativeLocation)
+    }
+
     if (isDeveloperMode()) {
         return file("$projectDir/../${getPlaygroundAppName()}/node_modules/react-native")
     }
-    return file("$projectDir/../../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
@@ -109,66 +132,90 @@ def getPlaygroundAppName() { // only for the development
     return playgroundAppName
 }
 
-boolean CLIENT_SIDE_BUILD = resolveClientSideBuild()
-if (CLIENT_SIDE_BUILD) {
-    configurations.maybeCreate("default")
+def shouldAssertNoMultipleInstances() {
+  if (rootProject.hasProperty("disableMultipleInstancesCheck")) {
+    return rootProject.property("disableMultipleInstancesCheck") != "true"
+  } else {
+    return true
+  }
+}
 
-    List<Path> paths = Files.find(
-            Paths.get(rootDir.parent),
-            Integer.MAX_VALUE,
-            {path, fileAttributes -> path.toString().endsWith("/react-native-reanimated/package.json") }
-    ).toArray()
+def findReanimatedInstancesForPath(String path) {
+    return fileTree(path) {
+        include "**/react-native-reanimated/package.json"
+        exclude "**/.yarn/**"
+        exclude {{ file, attr -> attr.isSymbolicLink() }}
+    }.files
+}
 
-    String parsedLocation = ""
-    def libInstancesCount = 0
-    for (def path in paths) {
-        parsedLocation += "- " + path.toString().replace("/package.json", "\n")
-        libInstancesCount++
+def checkNoMultipleInstances() {
+    // 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 (libInstancesCount > 1) {
-        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";
+    if (files.size() > 1) {
+        String parsedLocation = files.stream().map({
+            File file -> "- " + file.toString().replace("/package.json", "")
+        }).collect().join("\n")
+        String exceptionMessage = "\n[react-native-reanimated] Multiple 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)
     }
 }
-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 localProps = new Properties()
-def localPropertiesFile = file("local.properties")
-if (localPropertiesFile.exists()) {
-    localProps.load(new InputStreamReader(new FileInputStream(localPropertiesFile), "UTF-8"))
+def getReanimatedVersion() {
+    def inputFile = file(projectDir.path + '/../package.json')
+    def json = new JsonSlurper().parseText(inputFile.text)
+    String reanimatedVersion = json.version
+    def (major, minor, patch) = reanimatedVersion.tokenize('.')
+    return major.toInteger()
 }
 
-def debugNativeLibraries = localProps.getProperty('NATIVE_DEBUG_ON', 'FALSE').toBoolean()
+boolean CLIENT_SIDE_BUILD = resolveClientSideBuild()
+if (CLIENT_SIDE_BUILD) {
+    configurations.maybeCreate("default")
+}
+
+def reactNativeRootDir = resolveReactNativeDirectory()
+
 def reactProperties = new Properties()
-file("$reactNative/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
+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_VERSION = reactProperties.getProperty("VERSION_NAME").split("\\.")[1].toInteger()
+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")
+def REANIMATED_MAJOR_VERSION = getReanimatedVersion()
 
 // 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 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("$reactNative/ReactAndroid/src/main/jni/third-party")
+def reactNativeThirdParty = new File("$reactNativeRootDir/ReactAndroid/src/main/jni/third-party")
+def reactNativeAndroidDownloadDir = new File("$reactNativeRootDir/ReactAndroid/build/downloads")
 
 def _stackProtectorFlag = true
 
-def CMAKE_NODE_MODULES_DIR = CLIENT_SIDE_BUILD
-        ? project.getProjectDir().getParentFile().getParent()
-        : Paths.get(project.getProjectDir().getParent(), getPlaygroundAppName(), "node_modules").toString()
-
 def JS_RUNTIME = {
     // Returns the js runtime explicitly requested in the environment variable
     if (System.getenv("JS_RUNTIME")) {
@@ -187,15 +234,15 @@ def JS_RUNTIME = {
 
 def jsRuntimeDir = {
     if (JS_RUNTIME == "hermes") {
-        if (rnMinorVersion >= 69) {
-            return Paths.get(CMAKE_NODE_MODULES_DIR, "react-native", "sdks", "hermes")
+        if (REACT_NATIVE_MINOR_VERSION >= 69) {
+            return Paths.get(reactNativeRootDir.path, "sdks", "hermes")
         } else {
-            return Paths.get(CMAKE_NODE_MODULES_DIR, "hermes-engine")
+            return Paths.get(reactNativeRootDir.path, "..", "hermes-engine")
         }
     } else if (JS_RUNTIME == "v8") {
         return findProject(":react-native-v8").getProjectDir().getParent()
     } else {
-        return Paths.get(CMAKE_NODE_MODULES_DIR, "react-native", "ReactCommon", "jsi")
+        return Paths.get(reactNativeRootDir.path, "ReactCommon", "jsi")
     }
 }.call()
 
@@ -204,6 +251,145 @@ def reactNativeArchitectures() {
     return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
+def detectAAR(Integer rnMinorVersion, String engine) { // Reanimated2 only
+    def rnMinorVersionCopy = rnMinorVersion
+    def aar = file("react-native-reanimated-${rnMinorVersionCopy}-${engine}.aar")
+
+    if (aar.exists()) {
+        println "AAR for react-native-reanimated has been found\n$aar"
+        return aar
+    } else {
+        while (!aar.exists() && rnMinorVersionCopy >= 63) {
+            rnMinorVersionCopy -= 1
+            aar = file("react-native-reanimated-${rnMinorVersionCopy}-${engine}.aar")
+        }
+
+        if (rnMinorVersionCopy < 63) {
+            println "No AAR for react-native-reanimated found. Attempting to build from source."
+        } else { // aar exists, but was build for lower react-native version
+            println "\n\n\n"
+            println "****************************************************************************************"
+            println "\n\n\n"
+            println "WARNING reanimated - no version-specific reanimated AAR for react-native version $minor found."
+            println "Falling back to AAR for react-native version $rnMinorVersionCopy."
+            println "The react-native JSI interface is not ABI-safe yet, this may result in crashes."
+            println "Please post a pull request to implement support for react-native version $minor to the reanimated repo."
+            println "Thanks!"
+            println "\n\n\n"
+            println "****************************************************************************************"
+
+            return aar
+        }
+    }
+    return null
+}
+
+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
+            ) {
+                buildFromSourceConf = true
+            }
+        }
+    })
+    return buildFromSourceConf
+}
+
+def shouldBuildFromSource(aar, jsRuntimeName) { // Reanimated2 only
+    if (jsRuntimeName == "v8") {
+        return true
+    }
+    else if (isDeveloperMode()) {
+        // Example app
+        return true
+    }
+    else if (isUserDemandToBuildFromSource()) {
+        // on user demand
+        return true
+    }
+    else if (aar != null) {
+        // when binary exist
+        return false
+    }
+    // when binary is not found
+    return true
+}
+
+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) {
+        return task
+    }
+    pathName = "${appName}:${secondPart}${flavorString.capitalize()}${lastPart}"
+    return project.getTasks().findByPath(pathName)
+}
+
+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")
+        Task replaceSoTaskRelease = project.getTasks().findByPath(":react-native-reanimated:replaceSoTaskRelease")
+
+        if (replaceSoTaskDebug != null && replaceSoTaskRelease != null) {
+            rootProject.getSubprojects().forEach({project ->
+                if (project.plugins.hasPlugin("com.android.application") && project.getProperties().get("android")) {
+                    def projectProperties = project.getProperties()
+                    def flavorString = getCurrentFlavor()
+                    def reanimatedConf = projectProperties.get("reanimated")
+
+                    if (
+                    flavorString != "NOT-FOUND"
+                            && (!reanimatedConf || (reanimatedConf && !reanimatedConf.get("enablePackagingOptions")))
+                    ) {
+                        replaceSoTask.appName = projectProperties.path
+                        replaceSoTask.buildDir = projectProperties.buildDir
+                        def appName = projectProperties.path
+
+                        Task debugNativeLibsTask = getTaskByPath(project, appName, "merge", flavorString, "DebugNativeLibs")
+                        Task debugDebugSymbolsTask = getTaskByPath(project, appName, "strip", flavorString, "DebugDebugSymbols")
+                        Task releaseNativeLibsTask = getTaskByPath(project, appName, "merge", flavorString, "ReleaseNativeLibs")
+                        Task releaseDebugSymbolsTask = getTaskByPath(project, appName, "strip", flavorString, "ReleaseDebugSymbols")
+                        Task debugTask = getTaskByPath(project, appName, "package", flavorString, "Debug")
+                        Task releaseTask = getTaskByPath(project, appName, "package", flavorString, "Release")
+
+                        if (
+                        debugNativeLibsTask != null && debugDebugSymbolsTask != null
+                                && releaseNativeLibsTask != null && releaseDebugSymbolsTask != null
+                                && debugTask != null && releaseTask != null
+                        ) {
+                            replaceSoTaskDebug.dependsOn(debugNativeLibsTask, debugDebugSymbolsTask)
+                            debugTask.dependsOn(replaceSoTaskDebug)
+                            replaceSoTaskRelease.dependsOn(releaseNativeLibsTask, releaseDebugSymbolsTask)
+                            releaseTask.dependsOn(replaceSoTaskRelease)
+                        }
+                    }
+                }
+            })
+        }
+    }
+
+    artifacts.add("default", aar)
+}
+
+// end if already loaded aar
+if (!BUILD_FROM_SOURCE) {
+    return
+}
 // You need to have following folders in this directory:
 //   - boost_1_63_0
 //   - double-conversion-1.1.6
@@ -233,9 +419,9 @@ buildscript {
         }
     }
     dependencies {
-        classpath "com.android.tools.build:gradle:4.2.2"
-        classpath "de.undercouch:gradle-download-task:4.1.2"
-        classpath "com.diffplug.spotless:spotless-plugin-gradle:5.15.0"
+        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:6.11.0"
     }
 }
 
@@ -258,17 +444,16 @@ android {
         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}",
-                        "-DNODE_MODULES_DIR=${CMAKE_NODE_MODULES_DIR}",
+                        "-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()}",
-                        "-DRNVERSION=${rnMinorVersion}"
+                        "-DREANIMATED_PACKAGE_BUILD=${REANIMATED_PACKAGE_BUILD}"
                 abiFilters (*reactNativeArchitectures())
                 _stackProtectorFlag ? (cppFlags("-fstack-protector-all")) : null
             }
@@ -276,21 +461,41 @@ android {
 
         buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
         buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
-        buildConfigField("int", "REACT_NATIVE_VERSION", rnMinorVersion.toString())
+        buildConfigField("int", "REACT_NATIVE_MINOR_VERSION", REACT_NATIVE_MINOR_VERSION.toString())
     }
     externalNativeBuild {
         cmake {
             path "CMakeLists.txt"
-            version "3.18.1"
+        }
+    }
+    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",
@@ -298,6 +503,7 @@ android {
                 "**/libfolly_runtime.so",
                 "**/libglog.so",
                 "**/libhermes.so",
+                "**/libhermes-executor-debug.so",
                 "**/libreactnativejni.so",
                 "**/libjscexecutor.so",
                 "**/libv8executor.so",
@@ -326,18 +532,59 @@ android {
     sourceSets.main {
         java {
             if (isNewArchitectureEnabled()) {
-                srcDirs += [
-                        "src/fabric/java",
-                ]
+                srcDirs += "src/fabric/java"
             } else {
-                srcDirs += [
-                        "src/paper/java",
-                ]
+                srcDirs += "src/paper/java"
+            }
+
+            // messageQueueThread
+            if (REANIMATED_MAJOR_VERSION > 2) {
+                if (REACT_NATIVE_MINOR_VERSION <= 67) {
+                    srcDirs += "src/reactNativeVersionPatch/messageQueueThread/67"
+                } else {
+                    srcDirs += "src/reactNativeVersionPatch/messageQueueThread/latest"
+                }
+            }
+
+            // UIImplementation
+            if (REACT_NATIVE_MINOR_VERSION <= 64) {
+                srcDirs += "src/reactNativeVersionPatch/UIImplementation/64"
+            } else {
+                srcDirs += "src/reactNativeVersionPatch/UIImplementation/latest"
+            }
+
+            // nativeHierarchyManager
+            if (REACT_NATIVE_MINOR_VERSION <= 62) {
+                srcDirs += "src/reactNativeVersionPatch/nativeHierarchyManager/62"
+            } else {
+                srcDirs += "src/reactNativeVersionPatch/nativeHierarchyManager/latest"
             }
         }
     }
 }
 
+def assertNoMultipleInstances = task assertNoMultipleInstancesTask {
+    onlyIf { shouldAssertNoMultipleInstances() && CLIENT_SIDE_BUILD }
+    doFirst {
+        checkNoMultipleInstances()
+    }
+}
+
+def assertNoReanimated2WithNewArchitecture = task assertNoReanimated2WithNewArchitectureTask {
+    onlyIf { isNewArchitectureEnabled() && REANIMATED_MAJOR_VERSION == 2 }
+    doFirst {
+        throw new Exception(
+            "\n[react-native-reanimated] Reanimated 2.x does not support Fabric. " +
+            "Please upgrade to 3.x to use Reanimated with the New Architecture. " +
+            "For details, see https://blog.swmansion.com/announcing-reanimated-3-16167428c5f7"
+        )
+    }
+}
+
+tasks.preBuild {
+    dependsOn assertNoMultipleInstances, assertNoReanimated2WithNewArchitecture
+}
+
 task cleanCmakeCache() {
     tasks.getByName("clean").dependsOn(cleanCmakeCache)
     doFirst {
@@ -350,35 +597,75 @@ task printVersions {
     println "Gradle: ${project.gradle.gradleVersion}"
 }
 
-task Log {
-    println("building Reanimated2")
+task createNativeDepsDirectories() {
+    downloadsDir.mkdirs()
+    thirdPartyNdkDir.mkdirs()
 }
 
-task applyJavaPatches(type: Copy) {
-    def patchDirectory = file("${projectDir}/rnVersionPatch/${rnMinorVersion}")
-    if (patchDirectory.exists()) {
-        from ("${patchDirectory}") {
-            include "**/*.java"
+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
         }
-        into ("${projectDir}/src/main/java/com/swmansion/reanimated")
     }
 }
 
-task createNativeDepsDirectories(dependsOn: applyJavaPatches) {
-    downloadsDir.mkdirs()
-    thirdPartyNdkDir.mkdirs()
+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: createNativeDepsDirectories, type: Download) {
+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) {
@@ -392,7 +679,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)
@@ -408,7 +695,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)
@@ -427,7 +714,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)
@@ -483,12 +770,10 @@ 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 (rnMinorVersion >= 69 && !isNewArchitectureEnabled()) {
+if (REACT_NATIVE_MINOR_VERSION >= 69 && !isNewArchitectureEnabled()) {
     // copied from `react-native/ReactAndroid/hermes-engine/build.gradle`
 
-    def reactNativeRootDir = resolveReactNativeDirectory()
-    def customDownloadDir = System.getenv("REACT_NATIVE_DOWNLOADS_DIR")
-    def downloadDir = customDownloadDir ? new File(customDownloadDir) : new File(reactNativeRootDir, "sdks/download")
+    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.
@@ -513,7 +798,7 @@ if (rnMinorVersion >= 69 && !isNewArchitectureEnabled()) {
                 // 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 org.gradle.api.file.RelativePath(!file.isDirectory(), file.relativePath.segments.drop(1))
+                    file.relativePath = new RelativePath(!file.isDirectory(), file.relativePath.segments.drop(1))
                 }
             }
         }
@@ -522,13 +807,18 @@ if (rnMinorVersion >= 69 && !isNewArchitectureEnabled()) {
 }
 
 task prepareHermes() {
-    if (rnMinorVersion >= 69) {
+    if (REACT_NATIVE_MINOR_VERSION >= 69) {
         if (!isNewArchitectureEnabled()) {
             dependsOn(unzipHermes)
         }
 
         doLast {
-            def hermesAAR = file("$reactNative/android/com/facebook/react/hermes-engine/$reactNativeVersion/hermes-engine-$reactNativeVersion-${resolveBuildType()}.aar") // e.g. hermes-engine-0.70.0-rc.1-debug.aar
+            // 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)
             }
@@ -537,7 +827,7 @@ task prepareHermes() {
 
             copy {
                 from soFiles
-                from "$reactNative/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
+                from "$reactNativeRootDir/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
                 into "$thirdPartyNdkDir/hermes"
             }
         }
@@ -548,16 +838,16 @@ task prepareHermes() {
                 throw new GradleScriptException("Could not find the hermes-engine npm package", null)
             }
 
-            def hermesAAR = file("$hermesPackagePath/android/hermes-debug.aar")
+            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-debug.aar\"", null)
+                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 "$reactNative/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
+                from "$reactNativeRootDir/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
                 into "$thirdPartyNdkDir/hermes"
             }
         }
@@ -584,7 +874,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}" })
 
@@ -601,7 +891,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"
             }
         }
@@ -615,7 +905,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"
             }
         }
@@ -625,7 +915,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")
@@ -636,11 +926,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()
 }
@@ -656,31 +946,27 @@ dependencies {
     }
     implementation "com.facebook.react:react-native:+" // From node_modules
     implementation "androidx.transition:transition:1.1.0"
-    if (rnMinorVersion > 66) {
-        implementation "androidx.core:core:1.7.0"
-    }
-    else {
-        implementation "androidx.core:core:1.6.0"
-    }
+    implementation "androidx.core:core:1.6.0"
+    
     extractHeaders("com.facebook.fbjni:fbjni:" + FBJNI_VERSION + ":headers")
     extractSO("com.facebook.fbjni:fbjni:" + FBJNI_VERSION)
 
-    def jscAAR = fileTree("$reactNative/../jsc-android/dist/org/webkit/android-jsc").matching({ it.include "**/**/*.aar" }).singleFile
+    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 rnAAR = fileTree("$reactNativeRootDir/android").matching({ it.include rnAarMatcher }).singleFile
     def file = rnAAR.absoluteFile
     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"
     }
 }
@@ -694,12 +980,23 @@ task downloadNdkBuildDependencies {
     dependsOn(downloadGlog)
 }
 
-task prepareThirdPartyNdkHeaders(dependsOn:[downloadNdkBuildDependencies, prepareBoost, prepareDoubleConversion, prepareFolly, prepareGlog, unpackReactNativeAAR]) {
-}
+task prepareThirdPartyNdkHeaders(dependsOn:[
+    downloadNdkBuildDependencies,
+    prepareBoost,
+    prepareDoubleConversion,
+    prepareFolly,
+    prepareGlog,
+    unpackReactNativeAAR]
+) {}
 
 def nativeBuildDependsOn(dependsOnTask) {
-    def buildTasks = tasks.findAll({ task ->
-        !task.name.contains("Clean") && (task.name.contains("externalNative") || task.name.contains("CMake")) })
+    def buildTasks = tasks.findAll({ task -> (
+        !task.name.contains("Clean")
+        && (task.name.contains("externalNative")
+            || task.name.contains("CMake")
+            || task.name.contains("generateJsonModel")
+        )
+    ) })
     buildTasks.forEach { task -> task.dependsOn(dependsOnTask) }
 }
 
@@ -718,8 +1015,8 @@ afterEvaluate {
     })
 
     if (JS_RUNTIME == "hermes") {
-        extractAARHeaders.dependsOn(prepareHermes)
-        extractSOFiles.dependsOn(prepareHermes)
+      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")) })
@@ -727,12 +1024,17 @@ afterEvaluate {
             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"
-    def 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}.")
     }