in sources/android-integration/amper-android-gradle-plugin/src/org/jetbrains/amper/android/gradle/plugin.kt [95:248]
override fun apply(project: Project) {
val log = project.logger
val rootProjectBuildDir = project.rootProject.layout.buildDirectory.asFile.get().toPath()
val buildDir = rootProjectBuildDir / project.path.replace(":", "_")
project.layout.buildDirectory.set(buildDir.toFile())
project.repositories.google()
project.repositories.mavenCentral()
val module = project.gradle.projectPathToModule[project.path] ?: return
project.plugins.apply("com.android.application")
if ((module.buildDir / "google-services.json").exists()) {
project.plugins.apply("com.google.gms.google-services")
}
val androidExtension = project.extensions.findByType(AppExtension::class.java) ?: return
project.setArtifactBaseName()
val androidFragment = module
.fragments
.filterIsInstance<LeafFragment>()
.firstOrNull { it.platforms.contains(Platform.ANDROID) } ?: return
val androidSettings = androidFragment.settings.android
androidExtension.compileSdkVersion(androidSettings.compileSdk.versionNumber)
val signing = androidSettings.signing
if (signing.enabled) {
val path = (module.buildDir / signing.propertiesFile.pathString).normalize().absolute()
if (path.exists()) {
val keystoreProperties = path.readProperties()
androidExtension.signingConfigs { configs ->
configs.create(SIGNING_CONFIG_NAME) { config ->
keystoreProperties.storeFile?.let { storeFile ->
config.storeFile = (module.buildDir / Path(storeFile)).toFile()
}
keystoreProperties.storePassword?.let { storePassword ->
config.storePassword = storePassword
}
keystoreProperties.keyAlias?.let { keyAlias ->
config.keyAlias = keyAlias
}
keystoreProperties.keyPassword?.let { keyPassword ->
config.keyPassword = keyPassword
}
}
}
} else {
problems.reporter.reporting { problem ->
problem
.id("signing-properties-file-not-found", "Signing properties file not found")
.contextualLabel("Signing properties file not found")
.details("Signing properties file $path not found. Signing will not be configured")
.severity(Severity.WARNING)
.solution("Put signing properties file to $path")
}
log.warn("Properties file $path not found. Signing will not be configured")
}
}
androidExtension.defaultConfig {
it.maxSdk = androidSettings.maxSdk?.versionNumber
it.targetSdk = androidSettings.targetSdk.versionNumber
it.minSdk = androidSettings.minSdk.versionNumber
it.versionCode = androidSettings.versionCode
it.versionName = androidSettings.versionName
if (module.type == ProductType.ANDROID_APP) {
it.applicationId = androidSettings.applicationId
}
}
androidExtension.namespace = androidSettings.namespace
androidExtension.packagingOptions.resources {
val resourcePackaging = androidSettings.resourcePackaging
excludes.addAll(resourcePackaging.excludes.map { it.value })
merges.addAll(resourcePackaging.merges.map { it.value })
pickFirsts.addAll(resourcePackaging.pickFirsts.map { it.value })
}
androidExtension.buildTypes { types ->
types.getByName("release") { release ->
release.proguardFiles(
androidExtension.getDefaultProguardFile("proguard-android-optimize.txt"),
(module.buildDir / "proguard-rules.pro").toFile()
)
release.isDebuggable = false
release.isMinifyEnabled = true
release.isShrinkResources = true
androidExtension.signingConfigs.findByName(SIGNING_CONFIG_NAME)?.let { signing ->
release.signingConfig = signing
}
}
}
val requestedModules = project
.gradle
.request
?.modules
?.associate { it.modulePath to it } ?: mapOf()
androidExtension.sourceSets.matching { it.name == "main" }.all {
val androidApplicationSourceRoot = androidFragment
.singleSourceRoot("Android application must have a single source root")
.resolve("AndroidManifest.xml")
it.manifest.srcFile(androidApplicationSourceRoot)
it.res.setSrcDirs(setOf(module.buildDir.resolve("res")))
}
project.afterEvaluate {
// get variants
val variants = androidExtension.applicationVariants
// choose variant
val buildTypes = (project.gradle.request?.buildTypes ?: emptySet()).map { it.value }.toSet()
val chosenVariants = variants.filter { it.name in buildTypes }
for (variant in chosenVariants) {
val requestedModule = requestedModules[project.path] ?: return@afterEvaluate
// set dependencies
for (dependency in requestedModule.resolvedAndroidRuntimeDependencies) {
variant.runtimeConfiguration.dependencies.add(
ResolvedAmperDependency(
project,
dependency
)
)
}
// set inter-module dependencies between android modules
val androidDependencyPaths = project.gradle.knownModel?.let { _ ->
androidFragment
.externalDependencies
.asSequence()
.filterIsInstance<LocalModuleDependency>()
.map { it.module }
.filter { it.artifacts.any { artifact -> Platform.ANDROID in artifact.platforms } }
.mapNotNull { project.gradle.moduleFilePathToProject[it.buildDir] }
.filter { it in requestedModules }
.toList()
} ?: listOf()
for (path in androidDependencyPaths) {
variant.runtimeConfiguration.dependencies.add(project.dependencies.project(mapOf("path" to path)))
}
// set classes
requestedModule.moduleClasses.forEach {
variant.registerPostJavacGeneratedBytecode(project.files(it))
}
}
}
}