blob: 913caf434b95ae11e52b71ec5ea1bf81f1cfb378 [file] [log] [blame]
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.build.gradle.internal.tasks.structureplugin
import com.android.build.gradle.internal.plugins.BasePlugin
import com.android.ide.common.symbols.IdProvider
import com.android.ide.common.symbols.parseResourceSourceSetDirectory
import com.android.resources.ResourceType
import com.android.sdklib.AndroidTargetHash
import org.gradle.api.Action
import org.gradle.api.DefaultTask
import org.gradle.api.Project
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.ModuleDependency
import org.gradle.api.artifacts.ProjectDependency
import org.gradle.api.file.RegularFile
import org.gradle.api.plugins.JavaPluginConvention
import org.gradle.api.provider.Provider
import org.gradle.api.tasks.SourceSet
import org.gradle.api.tasks.TaskAction
import java.io.File
open class GatherModuleInfoTask : DefaultTask() {
private lateinit var sourceProjectName : String
lateinit var outputProvider : Provider<RegularFile>
private set
private var moduleDataHolder = ModuleInfo()
@TaskAction
fun action() {
AndroidCollector().collectInto(moduleDataHolder, this)
DependencyCollector().collectInto(moduleDataHolder, this)
KotlinUsageCollector().collectInto(moduleDataHolder, this)
SourceFilesCollector().collectInto(moduleDataHolder, this)
// Transform the ":" from the path into "_" so Poet can generate directories for each module
// correctly. Example: :module1:submoduleA will become module1_submoduleA
moduleDataHolder.name = sourceProjectName.replace(':', '_')
moduleDataHolder.saveAsJsonTo(outputProvider.get().asFile)
}
class ConfigAction(private val project: Project) : Action<GatherModuleInfoTask> {
override fun execute(task: GatherModuleInfoTask) {
task.sourceProjectName = project.name
task.outputProvider = project.layout.buildDirectory.file("local-module-info.json")
}
}
}
private interface DataCollector {
fun collectInto(dataHolder: ModuleInfo, task: GatherModuleInfoTask)
}
private class AndroidCollector : DataCollector {
override fun collectInto(dataHolder: ModuleInfo, task: GatherModuleInfoTask) {
if (!task.project.isAndroidProject()) return
dataHolder.type = ModuleType.ANDROID
task.project.plugins.withType(BasePlugin::class.java).firstOrNull()?.let {
collectBuildConfig(dataHolder, it)
collectResources(dataHolder, it)
}
}
private fun collectBuildConfig(dataHolder: ModuleInfo, plugin: BasePlugin) {
plugin.extension.defaultConfig.minSdkVersion?.apiLevel?.let {
dataHolder.androidBuildConfig.minSdkVersion = it }
plugin.extension.defaultConfig.targetSdkVersion?.apiLevel?.let {
dataHolder.androidBuildConfig.targetSdkVersion = it }
// extension.compileSdkVersion returns "android-27", we want just "27".
dataHolder.androidBuildConfig.compileSdkVersion =
AndroidTargetHash.getPlatformVersion(plugin.extension.compileSdkVersion)!!.apiLevel
}
private fun collectResources(dataHolder: ModuleInfo, plugin: BasePlugin) {
val resources = plugin.extension.sourceSets
.findByName(SourceSet.MAIN_SOURCE_SET_NAME)?.res ?: return
resources.srcDirs.forEach {
val symbolTable = parseResourceSourceSetDirectory(it, IdProvider.constant(), null)
// TODO add more resource types as ASPoet supports them
dataHolder.resources.imageCount +=
symbolTable.getSymbolByResourceType(ResourceType.DRAWABLE).size
dataHolder.resources.layoutCount +=
symbolTable.getSymbolByResourceType(ResourceType.LAYOUT).size
dataHolder.resources.stringCount +=
symbolTable.getSymbolByResourceType(ResourceType.STRING).size
}
}
}
private class SourceFilesCollector : DataCollector {
override fun collectInto(dataHolder: ModuleInfo, task: GatherModuleInfoTask) {
// Get the java sources from main (excludes tests for now) or just return if they are
// not there, since we do not have anything else to do.
val javaPackageMap = mutableMapOf<String, Int>()
val kotlinPackageMap = mutableMapOf<String, Int>()
task.project.findMainSourceSet().forEach {
it.walkBottomUp().toList().filter { !it.isDirectory }
.forEach {
val dirPackage = it.parent
when (it.extension) {
"java" -> javaPackageMap.increment(dirPackage)
"kt" -> kotlinPackageMap.increment(dirPackage)
}
}
}
dataHolder.javaSourceInfo.packages = javaPackageMap.size
if (javaPackageMap.isNotEmpty()) {
// Since ASPoet doesn't support count per package, we pick the biggest.
dataHolder.javaSourceInfo.classesPerPackage = javaPackageMap.values.max() ?: 0
dataHolder.javaSourceInfo.methodsPerClass = 10 // TODO actually count the methods
dataHolder.javaSourceInfo.fieldsPerClass = 10 // TODO actually count the fields
}
dataHolder.kotlinSourceInfo.packages = kotlinPackageMap.size
if (kotlinPackageMap.isNotEmpty()) {
// Since ASPoet doesn't support count per package, we pick the biggest.
dataHolder.kotlinSourceInfo.classesPerPackage = kotlinPackageMap.values.max() ?: 0
dataHolder.kotlinSourceInfo.methodsPerClass = 10 // TODO actually count the methods
dataHolder.kotlinSourceInfo.fieldsPerClass = 10 // TODO actually count the methods
}
}
private fun Project.findMainSourceSet(): Set<File> {
if (isAndroidProject()) {
val androidPlugin = plugins.withType(BasePlugin::class.java).first()
return androidPlugin.extension.sourceSets
.findByName(SourceSet.MAIN_SOURCE_SET_NAME)?.java?.srcDirs ?: emptySet()
} else {
val javaPlugin =
convention.findPlugin(JavaPluginConvention::class.java) ?: return emptySet()
return javaPlugin.sourceSets
.findByName(SourceSet.MAIN_SOURCE_SET_NAME)?.allSource?.srcDirs ?: emptySet()
}
}
private fun MutableMap<String, Int>.increment(key: String) {
this[key] = (this[key] ?: 0) + 1
}
}
private class KotlinUsageCollector : DataCollector {
override fun collectInto(dataHolder: ModuleInfo, task: GatherModuleInfoTask) {
if (task.project.usesKotlin()) dataHolder.useKotlin = true
}
private fun Project.usesKotlin(): Boolean {
return (isAndroidProject() && plugins.hasPlugin("kotlin-android")) ||
plugins.hasPlugin("kotlin")
}
}
private class DependencyCollector : DataCollector {
val relevantConfigurations = setOf(
"api", "implementation", "classpath",
"compile", "compileOnly",
"runtime", "runtimeOnly",
"testImplementation", "testCompile",
"androidTestImplementation", "androidTestCompile",
"annotationProcessor", "kapt",
"package", "provided", "wearApp"
)
override fun collectInto(dataHolder: ModuleInfo, task: GatherModuleInfoTask) {
val projectDependencies = task.project.configurations.asIterable()
.filter { relevantConfigurations.contains(it.name) }
.flatMap { gatherDependencies(it) }.asIterable()
.cleanDependencies(task.project)
dataHolder.dependencies.addAll(projectDependencies)
}
private fun gatherDependencies(config: Configuration): List<PoetDependenciesInfo> {
val deps = mutableListOf<PoetDependenciesInfo>()
for (dependency in config.allDependencies) when (dependency) {
is ProjectDependency -> PoetDependenciesInfo(
DependencyType.MODULE,
config.name,
// For sub modules, drop the first ":" from the path and transform the others
// into "_" so Poet can generate directories for each module correctly.
dependency.dependencyProject.path.drop(1).replace(':', '_')
)
is ModuleDependency -> PoetDependenciesInfo(
DependencyType.EXTERNAL_LIBRARY,
config.name,
"${dependency.group}:${dependency.name}:${dependency.version}"
)
else -> null
}?.let { deps.add(it) }
return deps
}
private fun Iterable<PoetDependenciesInfo>.cleanDependencies(project: Project): Iterable<PoetDependenciesInfo> {
var filteredDependencies = this
// Java modules that have the "kotlin" plugin applied creates repeated dependencies for
// kotlin jdk, so here we remove them to not pollute the resulting file.
if (project.plugins.hasPlugin("java-library") && project.plugins.hasPlugin("kotlin")) {
// Keep only the compile dependency if it's org.jetbrains.kotlin:kotlin-stdlib-jdk.
filteredDependencies = filteredDependencies.filter {
!it.dependency.startsWith("org.jetbrains.kotlin:kotlin-stdlib-jdk") ||
it.scope == "compile"
}
}
return filteredDependencies
}
}
private fun Project.isAndroidProject(): Boolean {
// "com.android.application", "com.android.library", "com.android.test"
return plugins.withType(BasePlugin::class.java).count() > 0
}