639 lines
22 KiB
Groovy
639 lines
22 KiB
Groovy
import groovy.json.JsonSlurper
|
|
import org.apache.tools.ant.filters.ReplaceTokens
|
|
import java.nio.file.Paths
|
|
|
|
static def findNodeModules(baseDir) {
|
|
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 nodeModulesPath = Paths.get(basePath.toString(), "node_modules")
|
|
def reactNativePath = Paths.get(nodeModulesPath.toString(), "react-native")
|
|
if (nodeModulesPath.toFile().exists() && reactNativePath.toFile().exists()) {
|
|
return nodeModulesPath.toString()
|
|
}
|
|
basePath = basePath.getParent()
|
|
}
|
|
throw new GradleException("VisionCamera: Failed to find node_modules/ path!")
|
|
}
|
|
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 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 nodeModules = findNodeModules(projectDir)
|
|
logger.warn("VisionCamera: node_modules/ found at: ${nodeModules}")
|
|
def reactNative = new File("$nodeModules/react-native")
|
|
def CMAKE_NODE_MODULES_DIR = project.getProjectDir().getParentFile().getParent()
|
|
def reactProperties = new Properties()
|
|
file("$nodeModules/react-native/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
|
|
def REACT_NATIVE_FULL_VERSION = reactProperties.getProperty("VERSION_NAME")
|
|
def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME").split("\\.")[1].toInteger()
|
|
|
|
def FOR_HERMES = System.getenv("FOR_HERMES") == "True"
|
|
rootProject.getSubprojects().forEach({project ->
|
|
if (project.plugins.hasPlugin("com.android.application")) {
|
|
FOR_HERMES = REACT_NATIVE_VERSION >= 71 && project.hermesEnabled || project.ext.react.enableHermes
|
|
}
|
|
})
|
|
def jsRuntimeDir = {
|
|
if (FOR_HERMES) {
|
|
if (REACT_NATIVE_VERSION >= 69) {
|
|
return Paths.get(CMAKE_NODE_MODULES_DIR, "react-native", "sdks", "hermes")
|
|
} else {
|
|
return Paths.get(CMAKE_NODE_MODULES_DIR, "hermes-engine")
|
|
}
|
|
} else {
|
|
return Paths.get(CMAKE_NODE_MODULES_DIR, "react-native", "ReactCommon", "jsi")
|
|
}
|
|
}.call()
|
|
logger.warn("VisionCamera: Building with ${FOR_HERMES ? "Hermes" : "JSC"}...")
|
|
|
|
buildscript {
|
|
// Buildscript is evaluated before everything else so we can't use getExtOrDefault
|
|
def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['VisionCamera_kotlinVersion']
|
|
|
|
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'
|
|
// noinspection DifferentKotlinGradleVersion
|
|
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
|
|
classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version"
|
|
}
|
|
}
|
|
|
|
apply plugin: 'com.android.library'
|
|
apply plugin: 'de.undercouch.download'
|
|
apply plugin: 'kotlin-android'
|
|
apply plugin: 'kotlin-android-extensions'
|
|
|
|
def getExtOrDefault(name) {
|
|
return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['VisionCamera_' + name]
|
|
}
|
|
|
|
def getExtOrIntegerDefault(name) {
|
|
return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['VisionCamera_' + name]).toInteger()
|
|
}
|
|
|
|
def resolveBuildType() {
|
|
def buildType = "debug"
|
|
tasks.all({ task ->
|
|
if (task.name == "buildCMakeRelease") {
|
|
buildType = "release"
|
|
}
|
|
})
|
|
return buildType
|
|
}
|
|
|
|
// plugin.js file only exists since REA v2.
|
|
def hasReanimated2 = file("${nodeModules}/react-native-reanimated/plugin.js").exists()
|
|
def disableFrameProcessors = rootProject.ext.has("disableFrameProcessors") ? rootProject.ext.get("disableFrameProcessors").asBoolean() : false
|
|
def ENABLE_FRAME_PROCESSORS = hasReanimated2 && !disableFrameProcessors
|
|
|
|
if (ENABLE_FRAME_PROCESSORS) {
|
|
logger.warn("VisionCamera: Frame Processors are enabled! Building C++ part...")
|
|
} else {
|
|
if (disableFrameProcessors) {
|
|
logger.warn("VisionCamera: Frame Processors are disabled because the user explicitly disabled it ('disableFrameProcessors=${disableFrameProcessors}'). C++ part will not be built.")
|
|
} else if (!hasReanimated2) {
|
|
logger.warn("VisionCamera: Frame Processors are disabled because REA v2 does not exist. C++ part will not be built.")
|
|
}
|
|
}
|
|
|
|
android {
|
|
compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
|
|
buildToolsVersion getExtOrDefault('buildToolsVersion')
|
|
ndkVersion getExtOrDefault('ndkVersion')
|
|
|
|
if (REACT_NATIVE_VERSION >= 71) {
|
|
buildFeatures {
|
|
prefab true
|
|
}
|
|
}
|
|
|
|
defaultConfig {
|
|
minSdkVersion 21
|
|
targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
|
|
|
|
if (ENABLE_FRAME_PROCESSORS) {
|
|
externalNativeBuild {
|
|
cmake {
|
|
cppFlags "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
|
|
abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
|
|
arguments '-DANDROID_STL=c++_shared',
|
|
"-DREACT_NATIVE_VERSION=${REACT_NATIVE_VERSION}",
|
|
"-DNODE_MODULES_DIR=${nodeModules}",
|
|
"-DFOR_HERMES=${FOR_HERMES}",
|
|
"-DJS_RUNTIME_DIR=${jsRuntimeDir}"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
dexOptions {
|
|
javaMaxHeapSize "4g"
|
|
}
|
|
|
|
if (ENABLE_FRAME_PROCESSORS) {
|
|
externalNativeBuild {
|
|
cmake {
|
|
path "CMakeLists.txt"
|
|
}
|
|
}
|
|
}
|
|
|
|
packagingOptions {
|
|
// Exclude all Libraries that are already present in the user's app (through React Native or by him installing REA)
|
|
excludes = ["**/libc++_shared.so",
|
|
"**/libfbjni.so",
|
|
"**/libjsi.so",
|
|
"**/libreactnativejni.so",
|
|
"**/libfolly_json.so",
|
|
"**/libreanimated.so",
|
|
"**/libjscexecutor.so",
|
|
"**/libhermes.so",
|
|
"**/libfolly_runtime.so",
|
|
"**/libglog.so",
|
|
]
|
|
// META-INF is duplicate by CameraX.
|
|
exclude "META-INF/**"
|
|
}
|
|
|
|
buildTypes {
|
|
release {
|
|
minifyEnabled false
|
|
}
|
|
}
|
|
|
|
lintOptions {
|
|
disable 'GradleCompatible'
|
|
}
|
|
compileOptions {
|
|
sourceCompatibility JavaVersion.VERSION_1_8
|
|
targetCompatibility JavaVersion.VERSION_1_8
|
|
}
|
|
|
|
configurations {
|
|
extractHeaders
|
|
extractJNI
|
|
}
|
|
}
|
|
|
|
repositories {
|
|
mavenCentral()
|
|
google()
|
|
|
|
def found = false
|
|
def defaultDir = null
|
|
def androidSourcesName = 'React Native sources'
|
|
|
|
if (rootProject.ext.has('reactNativeAndroidRoot')) {
|
|
defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
|
|
} else {
|
|
defaultDir = new File(
|
|
projectDir,
|
|
'/../../../node_modules/react-native/android'
|
|
)
|
|
}
|
|
|
|
if (defaultDir.exists()) {
|
|
maven {
|
|
url defaultDir.toString()
|
|
name androidSourcesName
|
|
}
|
|
|
|
logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
|
|
found = true
|
|
} else {
|
|
def parentDir = rootProject.projectDir
|
|
|
|
1.upto(5, {
|
|
if (found) return true
|
|
parentDir = parentDir.parentFile
|
|
|
|
def androidSourcesDir = new File(
|
|
parentDir,
|
|
'node_modules/react-native'
|
|
)
|
|
|
|
def androidPrebuiltBinaryDir = new File(
|
|
parentDir,
|
|
'node_modules/react-native/android'
|
|
)
|
|
|
|
if (androidPrebuiltBinaryDir.exists()) {
|
|
maven {
|
|
url androidPrebuiltBinaryDir.toString()
|
|
name androidSourcesName
|
|
}
|
|
|
|
logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
|
|
found = true
|
|
} else if (androidSourcesDir.exists()) {
|
|
maven {
|
|
url androidSourcesDir.toString()
|
|
name androidSourcesName
|
|
}
|
|
|
|
logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
|
|
found = true
|
|
}
|
|
})
|
|
}
|
|
|
|
if (!found) {
|
|
throw new GradleException(
|
|
"${project.name}: unable to locate React Native android sources. " +
|
|
"Ensure you have you installed React Native as a dependency in your project and try again."
|
|
)
|
|
}
|
|
}
|
|
|
|
def kotlin_version = getExtOrDefault('kotlinVersion')
|
|
|
|
dependencies {
|
|
if (REACT_NATIVE_VERSION >= 71) {
|
|
implementation "com.facebook.react:react-android:"
|
|
implementation "com.facebook.react:hermes-android:"
|
|
} else {
|
|
// noinspection GradleDynamicVersion
|
|
implementation 'com.facebook.react:react-native:+'
|
|
}
|
|
|
|
if (ENABLE_FRAME_PROCESSORS) {
|
|
implementation project(':react-native-reanimated')
|
|
|
|
if (REACT_NATIVE_VERSION < 71) {
|
|
//noinspection GradleDynamicVersion
|
|
extractHeaders("com.facebook.fbjni:fbjni:headers:+")
|
|
//noinspection GradleDynamicVersion
|
|
extractJNI("com.facebook.fbjni:fbjni:+")
|
|
|
|
def rnAarMatcher = "**/react-native/**/*${resolveBuildType()}.aar"
|
|
if (REACT_NATIVE_VERSION < 69) {
|
|
rnAarMatcher = "**/**/*.aar"
|
|
}
|
|
|
|
def rnAAR = fileTree("$reactNative/android").matching({ it.include rnAarMatcher }).singleFile
|
|
def jscAAR = fileTree("${nodeModules}/jsc-android/dist/org/webkit/android-jsc").matching({ it.include "**/**/*.aar" }).singleFile
|
|
extractJNI(files(rnAAR, jscAAR))
|
|
}
|
|
|
|
def jsEngine = FOR_HERMES ? "hermes" : "jsc"
|
|
def reaAAR = "${nodeModules}/react-native-reanimated/android/react-native-reanimated-${REACT_NATIVE_VERSION}-${jsEngine}.aar"
|
|
extractJNI(files(reaAAR))
|
|
}
|
|
|
|
implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
|
|
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-guava:1.5.2"
|
|
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.2"
|
|
|
|
implementation "androidx.camera:camera-core:1.1.0-beta02"
|
|
implementation "androidx.camera:camera-camera2:1.1.0-beta02"
|
|
implementation "androidx.camera:camera-lifecycle:1.1.0-beta02"
|
|
implementation "androidx.camera:camera-video:1.1.0-beta02"
|
|
|
|
implementation "androidx.camera:camera-view:1.1.0-beta02"
|
|
implementation "androidx.camera:camera-extensions:1.1.0-beta02"
|
|
|
|
implementation "androidx.exifinterface:exifinterface:1.3.3"
|
|
}
|
|
|
|
|
|
if (ENABLE_FRAME_PROCESSORS) {
|
|
// third-party-ndk deps headers
|
|
// mostly a copy of https://github.com/software-mansion/react-native-reanimated/blob/master/android/build.gradle#L115
|
|
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 thirdPartyVersionsFile = new File("${nodeModules}/react-native/ReactAndroid/gradle.properties")
|
|
def thirdPartyVersions = new Properties()
|
|
thirdPartyVersions.load(new FileInputStream(thirdPartyVersionsFile))
|
|
|
|
def BOOST_VERSION = thirdPartyVersions["BOOST_VERSION"]
|
|
def boost_file = new File(downloadsDir, "boost_${BOOST_VERSION}.tar.gz")
|
|
def DOUBLE_CONVERSION_VERSION = thirdPartyVersions["DOUBLE_CONVERSION_VERSION"]
|
|
def double_conversion_file = new File(downloadsDir, "double-conversion-${DOUBLE_CONVERSION_VERSION}.tar.gz")
|
|
def FOLLY_VERSION = thirdPartyVersions["FOLLY_VERSION"]
|
|
def folly_file = new File(downloadsDir, "folly-${FOLLY_VERSION}.tar.gz")
|
|
def GLOG_VERSION = thirdPartyVersions["GLOG_VERSION"]
|
|
def glog_file = new File(downloadsDir, "glog-${GLOG_VERSION}.tar.gz")
|
|
|
|
task createNativeDepsDirectories {
|
|
doLast {
|
|
downloadsDir.mkdirs()
|
|
thirdPartyNdkDir.mkdirs()
|
|
}
|
|
}
|
|
|
|
task downloadBoost(dependsOn: createNativeDepsDirectories, type: Download) {
|
|
def transformedVersion = BOOST_VERSION.replace("_", ".")
|
|
def srcUrl = "https://boostorg.jfrog.io/artifactory/main/release/${transformedVersion}/source/boost_${BOOST_VERSION}.tar.gz"
|
|
if (REACT_NATIVE_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(boost_file)
|
|
}
|
|
|
|
task prepareBoost(dependsOn: downloadBoost, type: Copy) {
|
|
from(tarTree(resources.gzip(downloadBoost.dest)))
|
|
from("src/main/jni/third-party/boost/Android.mk")
|
|
include("Android.mk", "boost_${BOOST_VERSION}/boost/**/*.hpp", "boost/boost/**/*.hpp")
|
|
includeEmptyDirs = false
|
|
into("$thirdPartyNdkDir") // /boost_X_XX_X
|
|
doLast {
|
|
file("$thirdPartyNdkDir/boost_${BOOST_VERSION}").renameTo("$thirdPartyNdkDir/boost")
|
|
}
|
|
}
|
|
|
|
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(double_conversion_file)
|
|
}
|
|
|
|
task prepareDoubleConversion(dependsOn: downloadDoubleConversion, type: Copy) {
|
|
from(tarTree(downloadDoubleConversion.dest))
|
|
from("src/main/jni/third-party/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(folly_file)
|
|
}
|
|
|
|
task prepareFolly(dependsOn: downloadFolly, type: Copy) {
|
|
from(tarTree(downloadFolly.dest))
|
|
from("src/main/jni/third-party/folly/Android.mk")
|
|
include("folly-${FOLLY_VERSION}/folly/**/*", "Android.mk")
|
|
eachFile { fname -> fname.path = (fname.path - "folly-${FOLLY_VERSION}/") }
|
|
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(glog_file)
|
|
}
|
|
|
|
task prepareGlog(dependsOn: downloadGlog, type: Copy) {
|
|
from(tarTree(downloadGlog.dest))
|
|
from("src/main/jni/third-party/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 prepareThirdPartyNdkHeaders {
|
|
if (!boost_file.exists()) {
|
|
dependsOn(prepareBoost)
|
|
}
|
|
if (!double_conversion_file.exists()) {
|
|
dependsOn(prepareDoubleConversion)
|
|
}
|
|
if (!folly_file.exists()) {
|
|
dependsOn(prepareFolly)
|
|
}
|
|
if (!glog_file.exists()) {
|
|
dependsOn(prepareGlog)
|
|
}
|
|
}
|
|
|
|
prepareThirdPartyNdkHeaders.mustRunAfter createNativeDepsDirectories
|
|
|
|
/*
|
|
COPY-PASTE from react-native-reanimated.
|
|
Vision Camera includes "hermes/hermes.h" header file in `NativeProxy.cpp`.
|
|
Previously, we used header files from `hermes-engine` package in `node_modules`.
|
|
Starting from React Native 0.69, Hermes is no longer distributed as package on NPM.
|
|
On the new architecture, Hermes is downloaded from GitHub and then compiled from sources.
|
|
However, on the old architecture, we need to download Hermes header files on our own
|
|
as well as unzip Hermes AAR in order to obtain `libhermes.so` shared library.
|
|
For more details, see https://reactnative.dev/architecture/bundled-hermes
|
|
or https://github.com/reactwg/react-native-new-architecture/discussions/4
|
|
*/
|
|
if (REACT_NATIVE_VERSION >= 69 && !isNewArchitectureEnabled()) {
|
|
// copied from `react-native/ReactAndroid/hermes-engine/build.gradle`
|
|
|
|
def customDownloadDir = System.getenv("REACT_NATIVE_DOWNLOADS_DIR")
|
|
def downloadDir = customDownloadDir ? new File(customDownloadDir) : new File(reactNative, "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(reactNative, "sdks/hermes")
|
|
|
|
def hermesVersion = "main"
|
|
def hermesVersionFile = new File(reactNative, "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)
|
|
}
|
|
}
|
|
|
|
task prepareHermes() {
|
|
if (REACT_NATIVE_VERSION >= 69) {
|
|
if (!isNewArchitectureEnabled()) {
|
|
dependsOn(unzipHermes)
|
|
}
|
|
|
|
doLast {
|
|
def hermesAAR = file("$reactNative/android/com/facebook/react/hermes-engine/$REACT_NATIVE_FULL_VERSION/hermes-engine-$REACT_NATIVE_FULL_VERSION-${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)
|
|
}
|
|
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
prepareHermes.mustRunAfter prepareThirdPartyNdkHeaders
|
|
|
|
task prepareJSC {
|
|
doLast {
|
|
def jscPackagePath = file("${nodeModules}/jsc-android")
|
|
if (!jscPackagePath.exists()) {
|
|
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")
|
|
}
|
|
}
|
|
}
|
|
|
|
prepareJSC.mustRunAfter prepareHermes
|
|
|
|
task extractAARHeaders {
|
|
doLast {
|
|
configurations.extractHeaders.files.each {
|
|
def file = it.absoluteFile
|
|
copy {
|
|
from zipTree(file)
|
|
into "$buildDir/$file.name"
|
|
include "**/*.h"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extractAARHeaders.mustRunAfter prepareJSC
|
|
|
|
task extractJNIFiles {
|
|
doLast {
|
|
configurations.extractJNI.files.each {
|
|
def file = it.absoluteFile
|
|
|
|
copy {
|
|
from zipTree(file)
|
|
into "$buildDir/$file.name"
|
|
include "jni/**/*"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extractJNIFiles.mustRunAfter extractAARHeaders
|
|
|
|
// pre-native build pipeline
|
|
|
|
tasks.whenTaskAdded { task ->
|
|
if (!task.name.contains('Clean') && (task.name.contains('externalNative') || task.name.contains('CMake'))) {
|
|
task.dependsOn(extractJNIFiles)
|
|
if (REACT_NATIVE_VERSION < 71) {
|
|
task.dependsOn(extractAARHeaders)
|
|
task.dependsOn(prepareThirdPartyNdkHeaders)
|
|
task.dependsOn(prepareJSC)
|
|
task.dependsOn(prepareHermes)
|
|
}
|
|
}
|
|
}
|
|
}
|