295 lines
11 KiB
Groovy
295 lines
11 KiB
Groovy
apply plugin: 'com.android.library'
|
|
apply plugin: 'com.facebook.react'
|
|
apply plugin: 'maven-publish'
|
|
|
|
android {
|
|
compileSdkVersion rootProject.ext.compileSdkVersion
|
|
ndkVersion rootProject.ext.ndkVersion
|
|
|
|
defaultConfig {
|
|
minSdkVersion rootProject.ext.minSdkVersion
|
|
targetSdkVersion rootProject.ext.targetSdkVersion
|
|
buildConfigField "String", "SDK_VERSION", "\"$sdkVersion\""
|
|
// Library modules don't get RN's app-mode CMake defaults; set them here.
|
|
externalNativeBuild {
|
|
cmake {
|
|
arguments "-DANDROID_STL=c++_shared",
|
|
"-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
|
|
"-DREACT_ANDROID_DIR=${rootProject.projectDir}/../node_modules/react-native/ReactAndroid",
|
|
"-DPROJECT_BUILD_DIR=${project.layout.buildDirectory.get().asFile}"
|
|
}
|
|
}
|
|
}
|
|
|
|
buildTypes {
|
|
debug {
|
|
buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
|
|
buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${rootProject.ext.googleServicesEnabled}"
|
|
}
|
|
release {
|
|
minifyEnabled false
|
|
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
|
|
buildConfigField "boolean", "LIBRE_BUILD", "${rootProject.ext.libreBuild}"
|
|
buildConfigField "boolean", "GOOGLE_SERVICES_ENABLED", "${rootProject.ext.googleServicesEnabled}"
|
|
}
|
|
}
|
|
|
|
sourceSets {
|
|
main {
|
|
java {
|
|
exclude "test/"
|
|
}
|
|
}
|
|
}
|
|
|
|
// JNI shim that registers TurboModules so consumers don't need libappmodules.so.
|
|
externalNativeBuild {
|
|
cmake { path 'src/main/jni/CMakeLists.txt' }
|
|
}
|
|
buildFeatures {
|
|
prefab true
|
|
}
|
|
// Exclude RN core .so files; consumers get them from react-android transitively.
|
|
packagingOptions {
|
|
excludes += [
|
|
"**/libc++_shared.so",
|
|
"**/libfbjni.so",
|
|
"**/libjsi.so",
|
|
"**/libreactnative.so",
|
|
"**/libreactnativejni.so",
|
|
"**/libturbomodulejsijni.so",
|
|
]
|
|
}
|
|
|
|
namespace 'org.jitsi.meet.sdk'
|
|
}
|
|
|
|
// Generate autolinking.cpp + Android-autolinking.cmake for our CMake to include.
|
|
def jitsiAutolinkOutDir = layout.buildDirectory.dir('generated/autolinking/src/main/jni')
|
|
def jitsiGenerateAutolinking = tasks.register('jitsiGenerateAutolinkingNewArchitectureFiles',
|
|
com.facebook.react.tasks.GenerateAutolinkingNewArchitecturesFileTask) {
|
|
autolinkInputFile.set(gradle.ext.autolinkingManifest)
|
|
generatedOutputDirectory.set(jitsiAutolinkOutDir)
|
|
}
|
|
|
|
// Run autolinking + per-lib codegen before any CMake task — our CMake reads them.
|
|
gradle.projectsEvaluated {
|
|
def rootAutolinkConfig = rootProject.tasks.findByName('generateAutolinkingConfigJson')
|
|
if (rootAutolinkConfig != null) {
|
|
jitsiGenerateAutolinking.configure { it.dependsOn(rootAutolinkConfig) }
|
|
}
|
|
def allCodegenTasks = rootProject.subprojects.collectMany { sub ->
|
|
sub.tasks.matching { it.name == 'generateCodegenArtifactsFromSchema' }
|
|
}
|
|
tasks.matching {
|
|
it.name.startsWith('configureCMake') ||
|
|
it.name.startsWith('buildCMake') ||
|
|
it.name.startsWith('externalNativeBuildClean')
|
|
}.configureEach {
|
|
it.dependsOn(allCodegenTasks)
|
|
it.dependsOn(jitsiGenerateAutolinking)
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
implementation fileTree(dir: 'libs', include: ['*.jar'])
|
|
implementation 'androidx.appcompat:appcompat:1.4.1'
|
|
implementation 'androidx.fragment:fragment:1.4.1'
|
|
implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'
|
|
implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
|
|
|
|
api "com.facebook.react:react-android:$rootProject.ext.rnVersion"
|
|
api "com.facebook.hermes:hermes-android:$rootProject.ext.hermesVersion"
|
|
|
|
implementation 'com.dropbox.core:dropbox-core-sdk:4.0.1'
|
|
implementation 'com.jakewharton.timber:timber:5.0.1'
|
|
implementation 'com.google.code.gson:gson:2.8.6'
|
|
implementation 'androidx.startup:startup-runtime:1.1.0'
|
|
implementation 'com.google.j2objc:j2objc-annotations:3.0.0'
|
|
|
|
// Autolinked RN modules come from settings.gradle; only the special cases below differ.
|
|
// webrtc uses `api` so consumers can access WebRTCModuleOptions.
|
|
def rnApiModules = [':react-native-webrtc']
|
|
def rnModuleExcludes = [
|
|
(':react-native-device-info') : ['com.google.firebase', 'com.google.android.gms', 'com.android.installreferrer'],
|
|
(':react-native-google-signin-google-signin') : ['com.google.android.gms', 'androidx']
|
|
]
|
|
|
|
// LIBRE_BUILD exclusions happen in settings.gradle.
|
|
(gradle.ext.autolinkedProjects ?: []).each { path ->
|
|
def conf = rnApiModules.contains(path) ? 'api' : 'implementation'
|
|
dependencies.add(conf, project(path)) {
|
|
rnModuleExcludes.getOrDefault(path, []).each { grp -> exclude group: grp }
|
|
}
|
|
}
|
|
|
|
testImplementation 'junit:junit:4.12'
|
|
}
|
|
|
|
|
|
// Here we bundle all assets, resources and React files. We cannot use the
|
|
// react.gradle file provided by react-native because it's designed to be used
|
|
// in an application (it taps into applicationVariants, but the SDK is a library
|
|
// so we need libraryVariants instead).
|
|
android.libraryVariants.all { def variant ->
|
|
// Create variant and target names
|
|
def targetName = variant.name.capitalize()
|
|
def targetPath = variant.dirName
|
|
|
|
// React js bundle directories
|
|
def jsBundleDir = file("$buildDir/generated/assets/react/${targetPath}")
|
|
def resourcesDir = file("$buildDir/generated/res/react/${targetPath}")
|
|
|
|
def jsBundleFile = file("$jsBundleDir/index.android.bundle")
|
|
|
|
def currentBundleTask = tasks.create(
|
|
name: "bundle${targetName}JsAndAssets",
|
|
type: Exec) {
|
|
group = "react"
|
|
description = "bundle JS and assets for ${targetName}."
|
|
|
|
// Create dirs if they are not there (e.g. the "clean" task just ran)
|
|
doFirst {
|
|
jsBundleDir.deleteDir()
|
|
jsBundleDir.mkdirs()
|
|
resourcesDir.deleteDir()
|
|
resourcesDir.mkdirs()
|
|
}
|
|
|
|
// Set up inputs and outputs so gradle can cache the result
|
|
def reactRoot = file("${projectDir}/../../")
|
|
inputs.files fileTree(dir: reactRoot, excludes: ["android/**", "ios/**"])
|
|
outputs.dir jsBundleDir
|
|
outputs.dir resourcesDir
|
|
|
|
// Set up the call to the react-native cli
|
|
workingDir reactRoot
|
|
|
|
// Set up dev mode
|
|
def devEnabled = !targetName.toLowerCase().contains("release")
|
|
|
|
commandLine(
|
|
"node",
|
|
"node_modules/react-native/scripts/bundle.js",
|
|
"--platform", "android",
|
|
"--dev", "${devEnabled}",
|
|
"--reset-cache",
|
|
"--entry-file", "index.android.js",
|
|
"--bundle-output", jsBundleFile,
|
|
"--assets-dest", resourcesDir)
|
|
|
|
// Disable bundling on dev builds
|
|
enabled !devEnabled
|
|
}
|
|
|
|
// Ensure proper task ordering for Gradle 8.14+ strict dependency validation
|
|
currentBundleTask.configure {
|
|
mustRunAfter {
|
|
def config = project.configurations.findByName("${targetPath}CompileClasspath")
|
|
|
|
// Fallback to an empty list(mustRunAfter expects a list, not "null" which is the og fallback),
|
|
// means no config, means no constraints
|
|
(config?.allDependencies ?: [])
|
|
.findAll { it.hasProperty('dependencyProject') }
|
|
.collectMany { dependency ->
|
|
project.project(dependency.dependencyProject.path)
|
|
.tasks.matching { it.name.contains(targetName) }
|
|
}
|
|
}
|
|
}
|
|
|
|
currentBundleTask.ext.generatedResFolders = files(resourcesDir).builtBy(currentBundleTask)
|
|
currentBundleTask.ext.generatedAssetsFolders = files(jsBundleDir).builtBy(currentBundleTask)
|
|
variant.registerGeneratedResFolders(currentBundleTask.generatedResFolders)
|
|
|
|
def mergeAssetsTask = variant.mergeAssetsProvider.get()
|
|
def mergeResourcesTask = variant.mergeResourcesProvider.get()
|
|
|
|
mergeAssetsTask.dependsOn(currentBundleTask)
|
|
mergeResourcesTask.dependsOn(currentBundleTask)
|
|
|
|
mergeAssetsTask.doLast {
|
|
def assetsDir = mergeAssetsTask.outputDir.get()
|
|
|
|
// Bundle sounds
|
|
//
|
|
copy {
|
|
from("${projectDir}/../../sounds")
|
|
include("*.wav")
|
|
include("*.mp3")
|
|
into("${assetsDir}/sounds")
|
|
}
|
|
|
|
// Copy React assets
|
|
//
|
|
if (currentBundleTask.enabled) {
|
|
copy {
|
|
from(jsBundleFile)
|
|
into(assetsDir)
|
|
}
|
|
}
|
|
}
|
|
|
|
mergeResourcesTask.doLast {
|
|
// Copy React resources
|
|
//
|
|
if (currentBundleTask.enabled) {
|
|
copy {
|
|
from(resourcesDir)
|
|
into(mergeResourcesTask.outputDir.get())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
publishing {
|
|
publications {
|
|
aarArchive(MavenPublication) {
|
|
groupId 'org.jitsi.react'
|
|
artifactId 'jitsi-meet-sdk'
|
|
version System.env.OVERRIDE_SDK_VERSION ?: project.sdkVersion
|
|
|
|
artifact("${project.buildDir}/outputs/aar/${project.name}-release.aar") {
|
|
extension "aar"
|
|
}
|
|
pom.withXml {
|
|
def pomXml = asNode()
|
|
pomXml.appendNode('name', 'jitsi-meet-sdk')
|
|
pomXml.appendNode('description', 'Jitsi Meet SDK for Android')
|
|
def dependencies = pomXml.appendNode('dependencies')
|
|
configurations.getByName('releaseCompileClasspath').getResolvedConfiguration().getFirstLevelModuleDependencies().each {
|
|
// The (third-party) React Native modules that we depend on
|
|
// are in source code form and do not have groupId. That is
|
|
// why we have a dedicated groupId for them. But the other
|
|
// dependencies come through Maven and, consequently, have
|
|
// groupId.
|
|
def groupId = it.moduleGroup
|
|
def artifactId = it.moduleName
|
|
|
|
if (artifactId.contains('react-native')) {
|
|
groupId = rootProject.ext.moduleGroupId
|
|
}
|
|
|
|
def dependency = dependencies.appendNode('dependency')
|
|
dependency.appendNode('groupId', groupId)
|
|
dependency.appendNode('artifactId', artifactId)
|
|
dependency.appendNode('version', it.moduleVersion)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
repositories {
|
|
maven {
|
|
url rootProject.ext.mavenRepo
|
|
if (!rootProject.ext.mavenRepo.startsWith("file")) {
|
|
credentials {
|
|
username rootProject.ext.mavenUser
|
|
password rootProject.ext.mavenPassword
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|