react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/android/build.gradle

@@ -1,10 +1,11 @@
+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 java.util.regex.Matcher
-import java.util.regex.Pattern
 import groovy.json.JsonSlurper
-import java.util.zip.ZipFile
+import java.util.stream.Stream
 
 /**
  * Finds the path of the installed npm package with the given name using Node's
@@ -45,22 +46,20 @@ 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 = "debug"
+    tasks.all({ task ->
+        if (task.name == "buildCMakeRelease") {
+            buildType = "release"
+        }
+    })
+    return buildType
 }
 
-def resolveBuildType() {
-    def buildType = System.getenv("CLIENT_SIDE_BUILD")
-    if (buildType != null) {
-        return buildType == "True"
+def resolveClientSideBuild() {
+    def clientSideBuild = System.getenv("CLIENT_SIDE_BUILD")
+    if (clientSideBuild != null) {
+        return clientSideBuild == "True"
     }
 
     if (hasProperty("clientSideBuild")) {
@@ -79,137 +78,57 @@ def isDeveloperMode() {
     return file("$projectDir/../node_modules/react-native/package.json").exists()
 }
 
+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() {
     if (isDeveloperMode()) {
-        return file("$projectDir/../node_modules/react-native")
+        return file("$projectDir/../${getPlaygroundAppName()}/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)
-                    }
-                }
+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)
             }
-        }
-        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
-                )
-            }
-        }
+        })
+    } catch(_) {
+        return "NOT_FOUND"
     }
+    return playgroundAppName
 }
 
-def detectAAR(minor, engine) {
-    def rnMinorVersionCopy = Integer.parseInt(minor)
-    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
-}
+boolean CLIENT_SIDE_BUILD = resolveClientSideBuild()
+if (CLIENT_SIDE_BUILD) {
+    configurations.maybeCreate("default")
 
-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
-            }
-        }
+    Stream<Path> pathStream = Files.find(
+            Paths.get(rootDir.parent),
+            Integer.MAX_VALUE,
+            (path, basicFileAttributes) -> { path.toString().endsWith("/react-native-reanimated/package.json") }
+    )
+
+    String parsedLocation = ""
+    def libInstancesCount = 0
+    pathStream.forEach(path -> {
+        parsedLocation += "- " + path.toString().replace("/package.json", "\n")
+        libInstancesCount++
     })
-    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
+    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";
+        throw new Exception(exceptionMessage)
     }
-    // when binary is not found
-    return true
-}
-
-boolean CLIENT_SIDE_BUILD = resolveBuildType()
-if (CLIENT_SIDE_BUILD) {
-    configurations.maybeCreate("default")
 }
 def reactNative = resolveReactNativeDirectory()
 def reactNativeManifest = file("$reactNative/package.json")
@@ -217,70 +136,6 @@ def reactNativeManifestAsJson = new JsonSlurper().parseText(reactNativeManifest.
 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")
-
-                    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
 
 def localProps = new Properties()
 def localPropertiesFile = file("local.properties")
@@ -309,13 +164,40 @@ 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 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")) {
+        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 (rnMinorVersion >= 69) {
+            return Paths.get(CMAKE_NODE_MODULES_DIR, "react-native", "sdks", "hermes")
+        } else {
+            return Paths.get(CMAKE_NODE_MODULES_DIR, "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")
+    }
+}.call()
 
 def reactNativeArchitectures() {
     def value = project.getProperties().get("reactNativeArchitectures")
@@ -351,8 +233,8 @@ buildscript {
         }
     }
     dependencies {
-        classpath "com.android.tools.build:gradle:7.1.1"
-        classpath "de.undercouch:gradle-download-task:5.0.1"
+        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"
     }
 }
@@ -372,6 +254,7 @@ 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",
@@ -379,9 +262,13 @@ android {
                         "-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}"
+                        "-DNODE_MODULES_DIR=${CMAKE_NODE_MODULES_DIR}",
+                        "-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}"
                 abiFilters (*reactNativeArchitectures())
                 _stackProtectorFlag ? (cppFlags("-fstack-protector-all")) : null
             }
@@ -389,10 +276,12 @@ android {
 
         buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
         buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
+        buildConfigField("int", "REACT_NATIVE_VERSION", rnMinorVersion.toString())
     }
     externalNativeBuild {
         cmake {
             path "CMakeLists.txt"
+            version "3.18.1"
         }
     }
     lintOptions {
@@ -411,6 +300,7 @@ android {
                 "**/libhermes.so",
                 "**/libreactnativejni.so",
                 "**/libjscexecutor.so",
+                "**/libv8executor.so",
         ]
     }
     tasks.withType(JavaCompile) {
@@ -425,6 +315,27 @@ 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",
+                ]
+            }
+        }
+    }
 }
 
 task cleanCmakeCache() {
@@ -435,7 +346,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}"
 }
 
@@ -562,23 +473,94 @@ 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 (rnMinorVersion >= 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")
+
+    // 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
+    }
+
+    task downloadHermes(type: Download) {
+        src("https://github.com/facebook/hermes/tarball/${hermesVersion}")
+        onlyIfNewer(true)
+        overwrite(false)
+        dest(new File(downloadDir, "hermes.tar.gz"))
+    }
+
+    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 org.gradle.api.file.RelativePath(!file.isDirectory(), file.relativePath.segments.drop(1))
+                }
+            }
+        }
+        into(hermesDir)
     }
+}
 
-    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 prepareHermes() {
+    if (rnMinorVersion >= 69) {
+        if (!isNewArchitectureEnabled()) {
+            dependsOn(unzipHermes)
+        }
 
-    def soFiles = zipTree(hermesAAR).matching({ it.include "**/*.so" })
+        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
+            if (!hermesAAR.exists()) {
+                throw new GradleScriptException("Could not find hermes-engine AAR", null)
+            }
 
-    copy {
-        from soFiles
-        from "$reactNative/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
-        into "$thirdPartyNdkDir/hermes"
+            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"
+            }
+        }
+    } 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-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"
+            }
+        }
     }
 }
 
@@ -666,7 +648,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 +656,28 @@ dependencies {
     }
     implementation "com.facebook.react:react-native:+" // From node_modules
     implementation "androidx.transition:transition:1.1.0"
+    implementation "androidx.core:core:1.7.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("$reactNative/../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) {
         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 file = rnAAR.absoluteFile
+    def packageName = file.name.tokenize('-')[0]
+    copy {
+        from zipTree(file)
+        into "$reactNative/ReactAndroid/src/main/jni/first-party/$packageName/"
+        include "jni/**/*.so"
+    }
 }
 
 task downloadNdkBuildDependencies {
@@ -701,7 +689,7 @@ task downloadNdkBuildDependencies {
     dependsOn(downloadGlog)
 }
 
-task prepareThirdPartyNdkHeaders(dependsOn:[downloadNdkBuildDependencies, prepareBoost, prepareDoubleConversion, prepareFolly, prepareGlog]) {
+task prepareThirdPartyNdkHeaders(dependsOn:[downloadNdkBuildDependencies, prepareBoost, prepareDoubleConversion, prepareFolly, prepareGlog, unpackReactNativeAAR]) {
 }
 
 def nativeBuildDependsOn(dependsOnTask) {
@@ -717,11 +705,29 @@ 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")
+        }
+    }
 }
 
 if (CLIENT_SIDE_BUILD) {
     def aarDir = "${buildDir}/outputs"
-    aar = file("${aarDir}/android-debug.aar")
+    def aar = file("${aarDir}/android-debug.aar")
     if (aar == null) {
         throw GradleScriptException("AAR build failed. No AAR found in ${aarDir}.")
     }