react-native-reanimated 2.3.3 → 2.5.0

package/android/build.gradle

@@ -1,26 +1,137 @@
-import groovy.json.JsonSlurper
+import java.nio.file.Paths
+import org.apache.tools.ant.filters.ReplaceTokens
+
 import java.util.regex.Matcher
 import java.util.regex.Pattern
-configurations.maybeCreate("default")
+import groovy.json.JsonSlurper
+import java.util.zip.ZipFile
 
-def inputFile = new File(projectDir, '../../react-native/package.json')
-def json = new JsonSlurper().parseText(inputFile.text)
-def reactNativeVersion = json.version as String
-def (major, minor, patch) = reactNativeVersion.tokenize('.')
+/**
+ * Finds the path of the installed npm package with the given name using Node's
+ * module resolution algorithm, which searches "node_modules" directories up to
+ * the file system root. This handles various cases, including:
+ *
+ *   - Working in the open-source RN repo:
+ *       Gradle: /path/to/react-native/ReactAndroid
+ *       Node module: /path/to/react-native/node_modules/[package]
+ *
+ *   - Installing RN as a dependency of an app and searching for hoisted
+ *     dependencies:
+ *       Gradle: /path/to/app/node_modules/react-native/ReactAndroid
+ *       Node module: /path/to/app/node_modules/[package]
+ *
+ *   - Working in a larger repo (e.g., Facebook) that contains RN:
+ *       Gradle: /path/to/repo/path/to/react-native/ReactAndroid
+ *       Node module: /path/to/repo/node_modules/[package]
+ *
+ * The search begins at the given base directory (a File object). The returned
+ * path is a string.
+ */
+static def findNodeModulePath(baseDir, packageName) {
+    def basePath = baseDir.toPath().normalize()
+    // Node's module resolution algorithm searches up to the root directory,
+    // after which the base path will be null
+    while (basePath) {
+        def candidatePath = Paths.get(basePath.toString(), "node_modules", packageName)
+        if (candidatePath.toFile().exists()) {
+            return candidatePath.toString()
+        }
+        basePath = basePath.getParent()
+    }
+    return null
+}
 
-def engine = "jsc"
+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)
+    }
+
+    return "NOT-FOUND"
+}
+
+def resolveBuildType() {
+    def buildType = System.getenv("CLIENT_SIDE_BUILD")
+    if (buildType != null) {
+        return buildType == "True"
+    }
+
+    if (hasProperty("clientSideBuild")) {
+        return property("clientSideBuild") == "true"
+    }
+
+    if (isDeveloperMode()) {
+        return false
+    }
+
+    return true
+}
+
+def resolveExpoLinkingGradle() {
+    def gradleScript = file("./expo/linking.gradle")
+    if (gradleScript.exists()) {
+        return "./expo/linking.gradle"
+    } else {
+        return "../android-npm/expo/linking.gradle"
+    }
+}
+
+def isDeveloperMode() {
+    // developer mode, to run Example app
+    return file("$projectDir/../node_modules/react-native/package.json").exists()
+}
+
+def resolveReactNativeDirectory() {
+    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: "../libSo/fbjni/jni/${abiVersion}/libfbjni.so",
+                        file: "${buildDir}/tmp/libSo/jni/${abiVersion}/libfbjni.so",
                         overwrite: true
                 )
             }
@@ -28,84 +139,586 @@ abstract class replaceSoTask extends DefaultTask {
     }
 }
 
-def getCurrentFlavor() {
-    Gradle gradle = getGradle()
-    String taskRequestName = gradle.getStartParameter().getTaskRequests().toString()
-    Pattern pattern = Pattern.compile("(assemble|bundle|install|generate)(\\w*)(Release|Debug)")
-    Matcher matcher = pattern.matcher(taskRequestName)
+def detectAAR(minor, engine) {
+    def rnMinorVersionCopy = Integer.parseInt(minor)
+    def aar = file("react-native-reanimated-${rnMinorVersionCopy}-${engine}.aar")
 
-    if(matcher.find()) {
-        return matcher.group(2)
+    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 $rnMinorVersion 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 $rnMinorVersion to the reanimated repo."
+            println "Thanks!"
+            println "\n\n\n"
+            println "****************************************************************************************"
+
+            return aar
+        }
     }
+    return null
+}
 
-    return "NOT-FOUND"
+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 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) {
+    if (isDeveloperMode()) {
+        // Example app
+        return true
+    }
+    else if (detectReanimatedConfig()) {
+        // on user demand
+        return true
+    }
+    else if (aar != null) {
+        // when binary exist
+        return false
+    }
+    // when binary is not found
+    return true
 }
 
-def replaceSoTaskDebug
-def replaceSoTaskRelease
-if(Integer.parseInt(minor) < 65) {
-    tasks.register("replaceSoTaskDebug", replaceSoTask)
-    tasks.register("replaceSoTaskRelease", replaceSoTask)
-    replaceSoTaskDebug = project.getTasks().getByPath(":react-native-reanimated:replaceSoTaskDebug")
-    replaceSoTaskRelease = project.getTasks().getByPath(":react-native-reanimated:replaceSoTaskRelease")
+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) {
+    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)
+}
+
+if (!BUILD_FROM_SOURCE) {
+    if (rnMinorVersion < 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")
 
-rootProject.getSubprojects().forEach({project ->
-    if (project.plugins.hasPlugin("com.android.application")) {
-        if(project.ext.react.enableHermes) {
-            engine = "hermes"
+                    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)
+                        }
+                    }
+                }
+            })
         }
+    }
 
-        if(project.getProperties().get("android") && Integer.parseInt(minor) < 65) {
-            def projectProperties = project.getProperties()
-            final NOTFOUND = "NOT-FOUND"
-            if(!NOTFOUND.equals(getCurrentFlavor()) && (!projectProperties.get("reanimated")
-                    || (projectProperties.get("reanimated") && projectProperties.get("reanimated").get("enablePackagingOptions")))
-            ) {
-                def flavorString = getCurrentFlavor()
-                replaceSoTask.appName = project.getProperties().path
-                replaceSoTask.buildDir = project.getProperties().buildDir
-                def appName = project.getProperties().path
-
-                replaceSoTaskDebug.dependsOn(
-                        project.getTasks().getByPath("${appName}:merge${flavorString}DebugNativeLibs"),
-                        project.getTasks().getByPath("${appName}:strip${flavorString}DebugDebugSymbols")
-                )
-                project.getTasks().getByPath("${appName}:package${flavorString}Debug").dependsOn(replaceSoTaskDebug)
+    artifacts.add("default", aar)
+}
 
-                replaceSoTaskRelease.dependsOn(
-                        project.getTasks().getByPath("${appName}:merge${flavorString}ReleaseNativeLibs"),
-                        project.getTasks().getByPath("${appName}:strip${flavorString}ReleaseDebugSymbols")
-                )
-                project.getTasks().getByPath("${appName}:package${flavorString}Release").dependsOn(replaceSoTaskRelease)
+// end if already loaded aar
+if (!BUILD_FROM_SOURCE) return
+
+// apply expo config
+apply from: resolveExpoLinkingGradle()
+
+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"]
+}
+
+// You need to have following folders in this directory:
+//   - boost_1_63_0
+//   - double-conversion-1.1.6
+//   - folly-deprecate-dynamic-initializer
+//   - glog-0.3.5
+def dependenciesPath = System.getenv("REACT_NATIVE_DEPENDENCIES")
+
+// The Boost library is a very large download (>100MB).
+// If Boost is already present on your system, define the REACT_NATIVE_BOOST_PATH env variable
+// and the build will use that.
+def boostPath = dependenciesPath ?: System.getenv("REACT_NATIVE_BOOST_PATH")
+
+def follyReplaceContent = '''
+  ssize_t r;
+  do {
+    r = open(name, flags, mode);
+  } while (r == -1 && errno == EINTR);
+  return r;
+'''
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+        maven {
+            url "https://plugins.gradle.org/m2/"
+        }
+    }
+    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"
+    }
+}
+
+if (project == rootProject) {
+    apply from: "spotless.gradle"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "maven-publish"
+apply plugin: "de.undercouch.download"
+
+android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 30)
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 16)
+        targetSdkVersion safeExtGet("targetSdkVersion", 30)
+        versionCode 1
+        versionName "1.0"
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_STL=c++_shared",
+                        "-DNATIVE_DEBUG=${debugNativeLibraries}",
+                        "-DREACT_NATIVE_TARGET_VERSION=${REACT_VERSION}",
+                        "-DANDROID_TOOLCHAIN=clang",
+                        "-DBOOST_VERSION=${BOOST_VERSION}",
+                        "-DBUILD_DIR=${buildDir}",
+                        "-DFOR_HERMES=${FOR_HERMES}",
+                        "-DCLIENT_SIDE_BUILD=${CLIENT_SIDE_BUILD}",
+                        "--clean-first"
+                abiFilters (*reactNativeArchitectures())
+                _stackProtectorFlag ? (cppFlags("-fstack-protector-all")) : null
             }
         }
+
+        buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
+        buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
+    }
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    packagingOptions {
+        println "Native libs debug enabled: ${debugNativeLibraries}"
+        doNotStrip debugNativeLibraries ? "**/**/*.so" : ''
+        excludes = [
+                "**/libc++_shared.so",
+                "**/libfbjni.so",
+                "**/libjsi.so",
+                "**/libfolly_json.so",
+                "**/libglog.so",
+                "**/libhermes.so",
+                "**/libreactnativejni.so",
+                "**/libjscexecutor.so",
+        ]
+    }
+    tasks.withType(JavaCompile) {
+        compileTask ->
+            compileTask.dependsOn(packageNdkLibs)
+    }
+    configurations {
+        extractHeaders
+        extractSO
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+task cleanCmakeCache() {
+    tasks.getByName("clean").dependsOn(cleanCmakeCache)
+    doFirst {
+        delete "${projectDir}/.cxx"
     }
-})
+}
+
+task printVersions {
+    println "Android gradle plugin: ${com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION}"
+    println "Gradle: ${project.gradle.gradleVersion}"
+}
 
-def minorCopy = Integer.parseInt(minor)
-def aar = file("react-native-reanimated-${minorCopy}-${engine}.aar")
+task Log {
+    println("building Reanimated2")
+}
 
-while (!aar.exists()) {
-    minorCopy -= 1
-    aar = file("react-native-reanimated-${minorCopy}-${engine}.aar")
-    if (minorCopy < 63) {
-      throw new GradleException('No aar for react-native-reanimated found.')
+task applyJavaPatches(type: Copy) {
+    def patchDirectory = file("${projectDir}/rnVersionPatch/${rnMinorVersion}")
+    if (patchDirectory.exists()) {
+        from ("${patchDirectory}") {
+            include "**/*.java"
+        }
+        into ("${projectDir}/src/main/java/com/swmansion/reanimated")
     }
-    if (aar.exists()) {
-      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 " . minorCopy
-      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 "****************************************************************************************"
-    }    
-}
-
-artifacts.add("default", aar)
-
-apply from: './expo/linking.gradle'
+}
+
+task createNativeDepsDirectories(dependsOn: applyJavaPatches) {
+    downloadsDir.mkdirs()
+    thirdPartyNdkDir.mkdirs()
+}
+
+task downloadBoost(dependsOn: createNativeDepsDirectories, type: Download) {
+    src("https://github.com/react-native-community/boost-for-react-native/releases/download/v${BOOST_VERSION.replace("_", ".")}-0/boost_${BOOST_VERSION}.tar.gz")
+    onlyIfNewer(true)
+    overwrite(false)
+    dest(new File(downloadsDir, "boost_${BOOST_VERSION}.tar.gz"))
+}
+
+task prepareBoost(dependsOn: boostPath ? [] : [downloadBoost], type: Copy) {
+    from(boostPath ?: tarTree(resources.gzip(downloadBoost.dest)))
+    from("$reactNativeThirdParty/boost/Android.mk")
+    include("Android.mk", "boost_${BOOST_VERSION}/boost/**/*.hpp", "boost/boost/**/*.hpp")
+    includeEmptyDirs = false
+    into("$thirdPartyNdkDir/boost")
+    doLast {
+        file("$thirdPartyNdkDir/boost/boost").renameTo("$thirdPartyNdkDir/boost/boost_${BOOST_VERSION}")
+    }
+}
+
+task downloadDoubleConversion(dependsOn: createNativeDepsDirectories, type: Download) {
+    src("https://github.com/google/double-conversion/archive/v${DOUBLE_CONVERSION_VERSION}.tar.gz")
+    onlyIfNewer(true)
+    overwrite(false)
+    dest(new File(downloadsDir, "double-conversion-${DOUBLE_CONVERSION_VERSION}.tar.gz"))
+}
+
+task prepareDoubleConversion(dependsOn: dependenciesPath ? [] : [downloadDoubleConversion], type: Copy) {
+    from(dependenciesPath ?: tarTree(downloadDoubleConversion.dest))
+    from("$reactNativeThirdParty/double-conversion/Android.mk")
+    include("double-conversion-${DOUBLE_CONVERSION_VERSION}/src/**/*", "Android.mk")
+    filesMatching("*/src/**/*", { fname -> fname.path = "double-conversion/${fname.name}" })
+    includeEmptyDirs = false
+    into("$thirdPartyNdkDir/double-conversion")
+}
+
+task downloadFolly(dependsOn: createNativeDepsDirectories, type: Download) {
+    src("https://github.com/facebook/folly/archive/v${FOLLY_VERSION}.tar.gz")
+    onlyIfNewer(true)
+    overwrite(false)
+    dest(new File(downloadsDir, "folly-${FOLLY_VERSION}.tar.gz"))
+}
+
+task prepareFolly(dependsOn: dependenciesPath ? [] : [downloadFolly], type: Copy) {
+    from(dependenciesPath ?: tarTree(downloadFolly.dest))
+    from("$reactNativeThirdParty/folly/Android.mk")
+    include("folly-${FOLLY_VERSION}/folly/**/*", "Android.mk")
+    eachFile { fname -> fname.path = (fname.path - "folly-${FOLLY_VERSION}/") }
+    // Fixes problem with Folly failing to build on certain systems. See
+    // https://github.com/software-mansion/react-native-reanimated/issues/1024
+    filter { line -> line.replaceAll("return int\\(wrapNoInt\\(open, name, flags, mode\\)\\);", follyReplaceContent) }
+    includeEmptyDirs = false
+    into("$thirdPartyNdkDir/folly")
+}
+
+task downloadGlog(dependsOn: createNativeDepsDirectories, type: Download) {
+    src("https://github.com/google/glog/archive/v${GLOG_VERSION}.tar.gz")
+    onlyIfNewer(true)
+    overwrite(false)
+    dest(new File(downloadsDir, "glog-${GLOG_VERSION}.tar.gz"))
+}
+
+// Prepare glog sources to be compiled, this task will perform steps that normally should've been
+// executed by automake. This way we can avoid dependencies on make/automake
+task prepareGlog(dependsOn: dependenciesPath ? [] : [downloadGlog], type: Copy) {
+    duplicatesStrategy = "include"
+    from(dependenciesPath ?: tarTree(downloadGlog.dest))
+    from("$reactNativeThirdParty/glog/")
+    include("glog-${GLOG_VERSION}/src/**/*", "Android.mk", "config.h")
+    includeEmptyDirs = false
+    filesMatching("**/*.h.in") {
+        filter(ReplaceTokens, tokens: [
+                ac_cv_have_unistd_h           : "1",
+                ac_cv_have_stdint_h           : "1",
+                ac_cv_have_systypes_h         : "1",
+                ac_cv_have_inttypes_h         : "1",
+                ac_cv_have_libgflags          : "0",
+                ac_google_start_namespace     : "namespace google {",
+                ac_cv_have_uint16_t           : "1",
+                ac_cv_have_u_int16_t          : "1",
+                ac_cv_have___uint16           : "0",
+                ac_google_end_namespace       : "}",
+                ac_cv_have___builtin_expect   : "1",
+                ac_google_namespace           : "google",
+                ac_cv___attribute___noinline  : "__attribute__ ((noinline))",
+                ac_cv___attribute___noreturn  : "__attribute__ ((noreturn))",
+                ac_cv___attribute___printf_4_5: "__attribute__((__format__ (__printf__, 4, 5)))"
+        ])
+        it.path = (it.name - ".in")
+    }
+    into("$thirdPartyNdkDir/glog")
+
+    doLast {
+        copy {
+            from(fileTree(dir: "$thirdPartyNdkDir/glog", includes: ["stl_logging.h", "logging.h", "raw_logging.h", "vlog_is_on.h", "**/src/glog/log_severity.h"]).files)
+            includeEmptyDirs = false
+            into("$thirdPartyNdkDir/glog/exported/glog")
+        }
+    }
+}
+
+task prepareHermes() {
+    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-debug.aar")
+    if (!hermesAAR.exists()) {
+        throw new GradleScriptException("The hermes-engine npm package is missing \"android/hermes-debug.aar\"", null)
+    }
+
+    def soFiles = zipTree(hermesAAR).matching({ it.include "**/*.so" })
+
+    copy {
+        from soFiles
+        from "$reactNative/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
+        into "$thirdPartyNdkDir/hermes"
+    }
+}
+
+task prepareJSC {
+    doLast {
+        def jscPackagePath = findNodeModulePath(projectDir, "jsc-android")
+        if (!jscPackagePath) {
+            throw new GradleScriptException("Could not find the jsc-android npm package", null)
+        }
+
+        def jscDist = file("$jscPackagePath/dist")
+        if (!jscDist.exists()) {
+            throw new GradleScriptException("The jsc-android npm package is missing its \"dist\" directory", null)
+        }
+
+        def jscAAR = fileTree(jscDist).matching({ it.include "**/android-jsc/**/*.aar" }).singleFile
+        def soFiles = zipTree(jscAAR).matching({ it.include "**/*.so" })
+
+        def headerFiles = fileTree(jscDist).matching({ it.include "**/include/*.h" })
+
+        copy {
+            from(soFiles)
+            from(headerFiles)
+            from("$reactNative/ReactAndroid/src/main/jni/third-party/jsc/Android.mk")
+
+            filesMatching("**/*.h", { it.path = "JavaScriptCore/${it.name}" })
+
+            includeEmptyDirs(false)
+            into("$thirdPartyNdkDir/jsc")
+        }
+    }
+}
+
+task extractAARHeaders {
+    doLast {
+        configurations.extractHeaders.files.each {
+            def file = it.absoluteFile
+            def packageName = file.name.tokenize('-')[0]
+            copy {
+                from zipTree(file)
+                into "$reactNative/ReactAndroid/src/main/jni/first-party/$packageName/headers"
+                include "**/*.h"
+            }
+        }
+    }
+}
+
+task extractSOFiles {
+    doLast {
+        configurations.extractSO.files.each {
+            def file = it.absoluteFile
+            def packageName = file.name.tokenize('-')[0]
+            copy {
+                from zipTree(file)
+                into "$reactNative/ReactAndroid/src/main/jni/first-party/$packageName/"
+                include "jni/**/*.so"
+            }
+        }
+    }
+}
+
+task packageNdkLibs(type: Copy) {
+    from("$buildDir/reanimated-ndk/all")
+    include("**/libreanimated.so")
+    if(REACT_VERSION < 64) {
+        include("**/libturbomodulejsijni.so")
+    }
+    into("$projectDir/src/main/jniLibs")
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url "$reactNative/android"
+    }
+    maven {
+        // Android JSC is installed from npm
+        url "$reactNative/../jsc-android/dist"
+    }
+    google()
+}
+
+dependencies {
+    // noinspection GradleDynamicVersion
+    implementation "com.facebook.yoga:proguard-annotations:1.19.0"
+    if (isDeveloperMode()) {
+        implementation "com.facebook.fbjni:fbjni:" + FBJNI_VERSION
+    }
+    else {
+        implementation "com.facebook.fbjni:fbjni-java-only:" + FBJNI_VERSION
+    }
+    implementation "com.facebook.react:react-native:+" // From node_modules
+    implementation "androidx.transition:transition:1.1.0"
+    extractHeaders("com.facebook.fbjni:fbjni:" + FBJNI_VERSION + ":headers")
+    extractSO("com.facebook.fbjni:fbjni:" + FBJNI_VERSION)
+
+    def rnAAR = fileTree("$reactNative/android").matching({ it.include "**/**/*.aar" }).singleFile
+    def jscAAR = fileTree("$reactNative/../jsc-android/dist/org/webkit/android-jsc").matching({ it.include "**/**/*.aar" }).singleFile
+    extractSO(files(rnAAR, jscAAR))
+}
+
+task downloadNdkBuildDependencies {
+    if (!boostPath) {
+        dependsOn(downloadBoost)
+    }
+    dependsOn(downloadDoubleConversion)
+    dependsOn(downloadFolly)
+    dependsOn(downloadGlog)
+}
+
+task prepareThirdPartyNdkHeaders(dependsOn:[downloadNdkBuildDependencies, prepareBoost, prepareDoubleConversion, prepareFolly, prepareGlog]) {
+}
+
+tasks.whenTaskAdded { task ->
+    if (
+        task.name.contains("externalNativeBuild")
+        || task.name.contains("buildCMake")
+    ) {
+        task.dependsOn(prepareThirdPartyNdkHeaders)
+        extractAARHeaders.dependsOn(prepareThirdPartyNdkHeaders)
+        extractSOFiles.dependsOn(prepareThirdPartyNdkHeaders)
+        task.dependsOn(extractAARHeaders)
+        task.dependsOn(extractSOFiles)
+    }
+}
+
+if (CLIENT_SIDE_BUILD) {
+    def aarDir = "${buildDir}/outputs"
+    aar = file("${aarDir}/android-debug.aar")
+    if (aar == null) {
+        throw GradleScriptException("AAR build failed. No AAR found in ${aarDir}.")
+    }
+    artifacts.add("default", aar)
+}