494 строки
19 KiB
Groovy
494 строки
19 KiB
Groovy
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
buildscript {
|
|
dependencies {
|
|
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${rootProject.hasProperty("kotlinVersion") ? rootProject.ext.kotlinVersion : KOTLIN_VERSION}"
|
|
}
|
|
}
|
|
|
|
plugins {
|
|
id("com.android.library")
|
|
id("com.facebook.react")
|
|
id("maven-publish")
|
|
id("de.undercouch.download")
|
|
}
|
|
|
|
import com.facebook.react.tasks.internal.*
|
|
|
|
import java.nio.file.Paths
|
|
|
|
import de.undercouch.gradle.tasks.download.Download
|
|
import org.apache.tools.ant.taskdefs.condition.Os
|
|
import org.apache.tools.ant.filters.ReplaceTokens
|
|
|
|
def AAR_OUTPUT_URL = "file://${projectDir}/../android"
|
|
// We download various C++ open-source dependencies into downloads.
|
|
// We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
|
|
// After that we build native code from src/main/jni with module path pointing at third-party-ndk.
|
|
|
|
def customDownloadsDir = System.getenv("REACT_NATIVE_DOWNLOADS_DIR")
|
|
def downloadsDir = customDownloadsDir ? new File(customDownloadsDir) : new File("$buildDir/downloads")
|
|
def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
|
|
def reactNativeRootDir = projectDir.parent
|
|
|
|
// You need to have following folders in this directory:
|
|
// - boost_1_76_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")
|
|
|
|
// Setup build type for NDK, supported values: {debug, release}
|
|
def nativeBuildType = System.getenv("NATIVE_BUILD_TYPE") ?: "release"
|
|
|
|
// We put the publishing version from gradle.properties inside ext. so other
|
|
// subprojects can access it as well.
|
|
ext.publishing_version = VERSION_NAME
|
|
|
|
task createNativeDepsDirectories {
|
|
downloadsDir.mkdirs()
|
|
thirdPartyNdkDir.mkdirs()
|
|
}
|
|
|
|
task downloadBoost(dependsOn: createNativeDepsDirectories, type: Download) {
|
|
src("https://boostorg.jfrog.io/artifactory/main/release/${BOOST_VERSION.replace("_", ".")}/source/boost_${BOOST_VERSION}.tar.gz")
|
|
onlyIfNewer(true)
|
|
overwrite(false)
|
|
dest(new File(downloadsDir, "boost_${BOOST_VERSION}.tar.gz"))
|
|
}
|
|
|
|
final def prepareBoost = tasks.register("prepareBoost", PrepareBoostTask) {
|
|
it.dependsOn(boostPath ? [] : [downloadBoost])
|
|
it.boostPath.setFrom(boostPath ?: tarTree(resources.gzip(downloadBoost.dest)))
|
|
it.boostVersion.set(BOOST_VERSION)
|
|
it.outputDir.set(new File(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(new File(downloadsDir, "double-conversion-${DOUBLE_CONVERSION_VERSION}.tar.gz"))
|
|
}
|
|
|
|
task prepareDoubleConversion(dependsOn: dependenciesPath ? [] : [downloadDoubleConversion], type: Copy) {
|
|
from(dependenciesPath ?: tarTree(downloadDoubleConversion.dest))
|
|
from("src/main/jni/third-party/double-conversion/")
|
|
include("double-conversion-${DOUBLE_CONVERSION_VERSION}/src/**/*", "CMakeLists.txt")
|
|
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("src/main/jni/third-party/folly/")
|
|
include("folly-${FOLLY_VERSION}/folly/**/*", "CMakeLists.txt")
|
|
eachFile { fname -> fname.path = (fname.path - "folly-${FOLLY_VERSION}/") }
|
|
includeEmptyDirs = false
|
|
into("$thirdPartyNdkDir/folly")
|
|
}
|
|
|
|
task downloadFmt(dependsOn: createNativeDepsDirectories, type: Download) {
|
|
src("https://github.com/fmtlib/fmt/archive/${FMT_VERSION}.tar.gz")
|
|
onlyIfNewer(true)
|
|
overwrite(false)
|
|
dest(new File(downloadsDir, "fmt-${FMT_VERSION}.tar.gz"))
|
|
}
|
|
|
|
task prepareFmt(dependsOn: dependenciesPath ? [] : [downloadFmt], type: Copy) {
|
|
from(dependenciesPath ?: tarTree(downloadFmt.dest))
|
|
from("src/main/jni/third-party/fmt/")
|
|
include("fmt-${FMT_VERSION}/src/**/*", "fmt-${FMT_VERSION}/include/**/*", "CMakeLists.txt")
|
|
eachFile { fname -> fname.path = (fname.path - "fmt-${FMT_VERSION}/") }
|
|
includeEmptyDirs = false
|
|
into("$thirdPartyNdkDir/fmt")
|
|
}
|
|
|
|
task downloadLibevent(dependsOn: createNativeDepsDirectories, type: Download) {
|
|
src("https://github.com/libevent/libevent/releases/download/release-${LIBEVENT_VERSION}-stable/libevent-${LIBEVENT_VERSION}-stable.tar.gz")
|
|
onlyIfNewer(true)
|
|
overwrite(false)
|
|
dest(new File(downloadsDir, "libevent-${LIBEVENT_VERSION}.tar.gz"))
|
|
}
|
|
|
|
|
|
final def prepareLibevent = tasks.register("prepareLibevent", PrepareLibeventTask) {
|
|
it.dependsOn(dependenciesPath ? [] : [downloadLibevent])
|
|
it.libeventPath.setFrom(dependenciesPath ?: tarTree(downloadLibevent.dest))
|
|
it.libeventVersion.set(LIBEVENT_VERSION)
|
|
it.outputDir.set(new File(thirdPartyNdkDir, "libevent"))
|
|
}
|
|
|
|
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
|
|
final def prepareGlog = tasks.register("prepareGlog", PrepareGlogTask) {
|
|
it.dependsOn(dependenciesPath ? [] : [downloadGlog])
|
|
it.glogPath.setFrom(dependenciesPath ?: tarTree(downloadGlog.dest))
|
|
it.glogVersion.set(GLOG_VERSION)
|
|
it.outputDir.set(new File(thirdPartyNdkDir, "glog"))
|
|
}
|
|
|
|
// Create Android native library module based on jsc from npm
|
|
tasks.register('prepareJSC', PrepareJSCTask) {
|
|
it.jscPackagePath.set(findNodeModulePath(projectDir, "jsc-android"))
|
|
it.outputDir = project.layout.buildDirectory.dir("third-party-ndk/jsc")
|
|
}
|
|
|
|
task downloadNdkBuildDependencies {
|
|
if (!boostPath) {
|
|
dependsOn(downloadBoost)
|
|
}
|
|
dependsOn(downloadDoubleConversion)
|
|
dependsOn(downloadFolly)
|
|
dependsOn(downloadGlog)
|
|
dependsOn(downloadFmt)
|
|
dependsOn(downloadLibevent)
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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 reactNativeDevServerPort() {
|
|
def value = project.getProperties().get("reactNativeDevServerPort")
|
|
return value != null ? value : "8081"
|
|
}
|
|
|
|
def reactNativeInspectorProxyPort() {
|
|
def value = project.getProperties().get("reactNativeInspectorProxyPort")
|
|
return value != null ? value : reactNativeDevServerPort()
|
|
}
|
|
|
|
def reactNativeArchitectures() {
|
|
def value = project.getProperties().get("reactNativeArchitectures")
|
|
return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
|
|
}
|
|
|
|
tasks.register("packageReactNdkLibsForBuck") {
|
|
dependsOn("packageReactNdkDebugLibsForBuck")
|
|
}
|
|
|
|
tasks.register("packageReactNdkDebugLibsForBuck", Copy) {
|
|
dependsOn("mergeDebugNativeLibs")
|
|
// Shared libraries (.so) are copied from the merged_native_libs folder instead
|
|
from("$buildDir/intermediates/merged_native_libs/debug/out/lib/")
|
|
exclude("**/libjsc.so")
|
|
exclude("**/libhermes.so")
|
|
into("src/main/jni/prebuilt/lib")
|
|
}
|
|
|
|
tasks.register("packageReactNdkReleaseLibsForBuck", Copy) {
|
|
dependsOn("mergeReleaseNativeLibs")
|
|
// Shared libraries (.so) are copied from the merged_native_libs folder instead
|
|
from("$buildDir/intermediates/merged_native_libs/release/out/lib/")
|
|
exclude("**/libjsc.so")
|
|
exclude("**/libhermes.so")
|
|
into("src/main/jni/prebuilt/lib")
|
|
}
|
|
|
|
final def extractNativeDependencies = tasks.register('extractNativeDependencies', ExtractJniAndHeadersTask) {
|
|
it.extractHeadersConfiguration.setFrom(configurations.extractHeaders)
|
|
it.extractJniConfiguration.setFrom(configurations.extractJNI)
|
|
it.baseOutputDir = project.file("src/main/jni/first-party/")
|
|
}
|
|
|
|
task installArchives {
|
|
dependsOn("publishAllPublicationsToNpmRepository")
|
|
}
|
|
|
|
android {
|
|
buildToolsVersion = "31.0.0"
|
|
compileSdkVersion 31
|
|
|
|
// Used to override the NDK path/version on internal CI or by allowing
|
|
// users to customize the NDK path/version from their root project (e.g. for M1 support)
|
|
if (rootProject.hasProperty("ndkPath")) {
|
|
ndkPath rootProject.ext.ndkPath
|
|
}
|
|
if (rootProject.hasProperty("ndkVersion")) {
|
|
ndkVersion rootProject.ext.ndkVersion
|
|
}
|
|
|
|
defaultConfig {
|
|
minSdkVersion(21)
|
|
targetSdkVersion(31)
|
|
versionCode(1)
|
|
versionName("1.0")
|
|
|
|
consumerProguardFiles("proguard-rules.pro")
|
|
|
|
buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
|
|
buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
|
|
buildConfigField("int", "HERMES_BYTECODE_VERSION", "0")
|
|
|
|
resValue "integer", "react_native_dev_server_port", reactNativeDevServerPort()
|
|
resValue "integer", "react_native_inspector_proxy_port", reactNativeInspectorProxyPort()
|
|
|
|
testApplicationId("com.facebook.react.tests.gradle")
|
|
testInstrumentationRunner("androidx.test.runner.AndroidJUnitRunner")
|
|
|
|
externalNativeBuild {
|
|
cmake {
|
|
arguments "-DREACT_COMMON_DIR=${reactNativeRootDir}/ReactCommon",
|
|
"-DREACT_ANDROID_DIR=$projectDir",
|
|
"-DREACT_BUILD_DIR=$buildDir",
|
|
"-DANDROID_STL=c++_shared",
|
|
"-DANDROID_TOOLCHAIN=clang",
|
|
"-DANDROID_PLATFORM=android-21"
|
|
|
|
targets "reactnativejni",
|
|
"jscexecutor",
|
|
"jsijniprofiler",
|
|
"reactnativeblob",
|
|
"reactperfloggerjni",
|
|
"react_newarchdefaults",
|
|
"turbomodulejsijni",
|
|
"fabricjni"
|
|
}
|
|
}
|
|
ndk {
|
|
abiFilters (*reactNativeArchitectures())
|
|
}
|
|
}
|
|
|
|
buildTypes {
|
|
debug {
|
|
externalNativeBuild {
|
|
cmake {
|
|
targets "hermes-executor-debug"
|
|
}
|
|
}
|
|
}
|
|
|
|
release {
|
|
externalNativeBuild {
|
|
cmake {
|
|
targets "hermes-executor-release"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
externalNativeBuild {
|
|
cmake {
|
|
path "src/main/jni/CMakeLists.txt"
|
|
}
|
|
}
|
|
|
|
preBuild.dependsOn(prepareJSC, prepareBoost, prepareDoubleConversion, prepareFmt, prepareFolly, prepareGlog, prepareLibevent, extractNativeDependencies)
|
|
preBuild.dependsOn("generateCodegenArtifactsFromSchema")
|
|
|
|
sourceSets.main {
|
|
res.srcDirs = ["src/main/res/devsupport", "src/main/res/shell", "src/main/res/views/modal", "src/main/res/views/uimanager"]
|
|
java {
|
|
srcDirs = ["src/main/java", "src/main/libraries/soloader/java", "src/main/jni/first-party/fb/jni/java"]
|
|
exclude("com/facebook/react/processing")
|
|
exclude("com/facebook/react/module/processing")
|
|
}
|
|
}
|
|
|
|
lintOptions {
|
|
abortOnError(false)
|
|
}
|
|
|
|
packagingOptions {
|
|
exclude("META-INF/NOTICE")
|
|
exclude("META-INF/LICENSE")
|
|
// We intentionally don't want to bundle any JS Runtime inside the Android AAR
|
|
// we produce. The reason behind this is that we want to allow users to pick the
|
|
// JS engine by specifying a dependency on either `hermes-engine` or `android-jsc`
|
|
// that will include the necessary .so files to load.
|
|
exclude("**/libhermes.so")
|
|
exclude("**/libjsc.so")
|
|
}
|
|
|
|
configurations {
|
|
extractHeaders
|
|
extractJNI
|
|
}
|
|
|
|
buildFeatures {
|
|
prefab true
|
|
}
|
|
|
|
publishing {
|
|
multipleVariants {
|
|
withSourcesJar()
|
|
allVariants()
|
|
}
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
api("androidx.appcompat:appcompat-resources:${ANDROIDX_APPCOMPAT_VERSION}")
|
|
api("androidx.appcompat:appcompat:${ANDROIDX_APPCOMPAT_VERSION}")
|
|
api("androidx.autofill:autofill:${ANDROIDX_AUTOFILL_VERSION}")
|
|
api("androidx.swiperefreshlayout:swiperefreshlayout:${SWIPEREFRESH_LAYOUT_VERSION}")
|
|
api("androidx.tracing:tracing:${ANDROIDX_TRACING_VERSION}")
|
|
|
|
api("com.facebook.fbjni:fbjni-java-only:${FBJNI_VERSION}")
|
|
api("com.facebook.fresco:fresco:${FRESCO_VERSION}")
|
|
api("com.facebook.fresco:imagepipeline-okhttp3:${FRESCO_VERSION}")
|
|
api("com.facebook.fresco:ui-common:${FRESCO_VERSION}")
|
|
api("com.facebook.infer.annotation:infer-annotation:${INFER_ANNOTATIONS_VERSION}")
|
|
api("com.facebook.soloader:soloader:${SO_LOADER_VERSION}")
|
|
api("com.facebook.yoga:proguard-annotations:${PROGUARD_ANNOTATIONS_VERSION}")
|
|
|
|
api("com.google.code.findbugs:jsr305:${JSR305_VERSION}")
|
|
api("com.squareup.okhttp3:okhttp-urlconnection:${OKHTTP_VERSION}")
|
|
api("com.squareup.okhttp3:okhttp:${OKHTTP_VERSION}")
|
|
api("com.squareup.okio:okio:${OKIO_VERSION}")
|
|
api("javax.inject:javax.inject:${JAVAX_INJECT_VERSION}")
|
|
|
|
extractHeaders("com.facebook.fbjni:fbjni:${FBJNI_VERSION}:headers")
|
|
extractJNI("com.facebook.fbjni:fbjni:${FBJNI_VERSION}")
|
|
|
|
// It's up to the consumer to decide if hermes should be included or not.
|
|
// Therefore hermes-engine is a compileOnly dependency.
|
|
compileOnly(project(":ReactAndroid:hermes-engine"))
|
|
|
|
testImplementation("junit:junit:${JUNIT_VERSION}")
|
|
testImplementation("org.assertj:assertj-core:${ASSERTJ_VERSION}")
|
|
testImplementation("org.mockito:mockito-core:${MOCKITO_CORE_VERSION}")
|
|
testImplementation("org.powermock:powermock-api-mockito2:${POWERMOCK_VERSION}")
|
|
testImplementation("org.powermock:powermock-classloading-xstream:${POWERMOCK_VERSION}")
|
|
testImplementation("org.powermock:powermock-module-junit4-rule:${POWERMOCK_VERSION}")
|
|
testImplementation("org.robolectric:robolectric:${ROBOLECTRIC_VERSION}")
|
|
|
|
androidTestImplementation(fileTree(dir: "src/main/third-party/java/buck-android-support/", include: ["*.jar"]))
|
|
androidTestImplementation("androidx.test:runner:${ANDROIDX_TEST_VERSION}")
|
|
androidTestImplementation("androidx.test:rules:${ANDROIDX_TEST_VERSION}")
|
|
androidTestImplementation("org.mockito:mockito-core:${MOCKITO_CORE_VERSION}")
|
|
}
|
|
|
|
react {
|
|
// TODO: The library name is chosen for parity with Fabric components & iOS
|
|
// This should be changed to a more generic name, e.g. `ReactCoreSpec`.
|
|
libraryName = "rncore"
|
|
root = file("..")
|
|
jsRootDir = file("../Libraries")
|
|
reactNativeDir = file("$projectDir/..")
|
|
useJavaGenerator = System.getenv("USE_CODEGEN_JAVAPOET")?.toBoolean() ?: false
|
|
// We search for the codegen in either one of the `node_modules` folder or in the
|
|
// root packages folder (that's for when we build from source without calling `yarn install`).
|
|
codegenDir = file(findNodeModulePath(projectDir, "react-native-codegen") ?: "../packages/react-native-codegen/")
|
|
}
|
|
|
|
afterEvaluate {
|
|
// Needed as some of the native sources needs to be downloaded
|
|
// before configureNdkBuildDebug could be executed.
|
|
reactNativeArchitectures().each { architecture ->
|
|
tasks.findByName("configureCMakeDebug[${architecture}]")?.configure { dependsOn(preBuild) }
|
|
tasks.findByName("configureCMakeRelWithDebInfo[${architecture}]")?.configure { dependsOn(preBuild) }
|
|
}
|
|
configureCMakeDebug.dependsOn(preBuild)
|
|
configureCMakeRelWithDebInfo.dependsOn(preBuild)
|
|
|
|
publishing {
|
|
publications {
|
|
release(MavenPublication) {
|
|
// We do a multi variant release
|
|
from components.default
|
|
|
|
// You can then customize attributes of the publication as shown below.
|
|
artifactId = POM_ARTIFACT_ID
|
|
groupId = GROUP
|
|
version = VERSION_NAME
|
|
|
|
pom {
|
|
name = POM_NAME
|
|
description = "A framework for building native apps with React"
|
|
url = "https://github.com/facebook/react-native"
|
|
|
|
developers {
|
|
developer {
|
|
id = "facebook"
|
|
name = "Facebook"
|
|
}
|
|
}
|
|
|
|
licenses {
|
|
license {
|
|
name = "MIT License"
|
|
url = "https://github.com/facebook/react-native/blob/HEAD/LICENSE"
|
|
distribution = "repo"
|
|
}
|
|
}
|
|
|
|
scm {
|
|
url = "https://github.com/facebook/react-native.git"
|
|
connection = "scm:git:https://github.com/facebook/react-native.git"
|
|
developerConnection = "scm:git:git@github.com:facebook/react-native.git"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
repositories {
|
|
maven {
|
|
name = "npm"
|
|
url = AAR_OUTPUT_URL
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
apply plugin: "org.jetbrains.kotlin.android"
|