244 lines
8.2 KiB
Kotlin
244 lines
8.2 KiB
Kotlin
/*
|
|
* Copyright 2020 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 androidx.compose.material.icons.generator.tasks
|
|
|
|
import androidx.compose.material.icons.generator.Icon
|
|
import androidx.compose.material.icons.generator.IconProcessor
|
|
import com.android.build.gradle.LibraryExtension
|
|
import org.gradle.api.DefaultTask
|
|
import org.gradle.api.Project
|
|
import org.gradle.api.tasks.CacheableTask
|
|
import org.gradle.api.tasks.Input
|
|
import org.gradle.api.tasks.InputDirectory
|
|
import org.gradle.api.tasks.InputFile
|
|
import org.gradle.api.tasks.Optional
|
|
import org.gradle.api.tasks.OutputDirectory
|
|
import org.gradle.api.tasks.OutputFile
|
|
import org.gradle.api.tasks.PathSensitive
|
|
import org.gradle.api.tasks.PathSensitivity
|
|
import org.gradle.api.tasks.TaskAction
|
|
import org.gradle.api.tasks.Internal
|
|
import org.gradle.api.tasks.TaskProvider
|
|
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
|
|
import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
|
|
import java.io.File
|
|
import java.util.Locale
|
|
|
|
/**
|
|
* Base [org.gradle.api.Task] for tasks relating to icon generation.
|
|
*/
|
|
@CacheableTask
|
|
abstract class IconGenerationTask : DefaultTask() {
|
|
|
|
/**
|
|
* Directory containing raw drawables. These icons will be processed to generate programmatic
|
|
* representations.
|
|
*/
|
|
@PathSensitive(PathSensitivity.RELATIVE)
|
|
@InputDirectory
|
|
val allIconsDirectory =
|
|
project.rootProject.project(GeneratorProject).projectDir.resolve("raw-icons")
|
|
|
|
/**
|
|
* Specific theme to generate icons for, or null to generate all
|
|
*/
|
|
@Optional
|
|
@Input
|
|
var themeName: String? = null
|
|
|
|
/**
|
|
* Specific icon directories to use in this task
|
|
*/
|
|
@Internal
|
|
fun getIconDirectories(): List<File> {
|
|
val themeName = themeName
|
|
if (themeName != null) {
|
|
return listOf(allIconsDirectory.resolve(themeName))
|
|
} else {
|
|
return allIconsDirectory.listFiles()!!.filter { it.isDirectory }
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checked-in API file for the generator module, where we will track all the generated icons
|
|
*/
|
|
@PathSensitive(PathSensitivity.NONE)
|
|
@InputFile
|
|
val expectedApiFile =
|
|
project.rootProject.project(GeneratorProject).projectDir.resolve("api/icons.txt")
|
|
|
|
/**
|
|
* Root build directory for this task, where outputs will be placed into.
|
|
*/
|
|
@OutputDirectory
|
|
lateinit var buildDirectory: File
|
|
|
|
/**
|
|
* Generated API file that will be placed in the build directory. This can be copied manually
|
|
* to [expectedApiFile] to confirm that API changes were intended.
|
|
*/
|
|
@get:OutputFile
|
|
val generatedApiFile: File
|
|
get() = buildDirectory.resolve("api/icons.txt")
|
|
|
|
/**
|
|
* @return a list of all processed [Icon]s from [getIconDirectories].
|
|
*/
|
|
fun loadIcons(): List<Icon> {
|
|
// material-icons-core loads and verifies all of the icons from all of the themes:
|
|
// both that all icons are present in all themes, and also that no icons have been removed.
|
|
// So, when we're loading just one theme, we don't need to verify it
|
|
val verifyApi = themeName == null
|
|
return IconProcessor(
|
|
getIconDirectories(),
|
|
expectedApiFile,
|
|
generatedApiFile,
|
|
verifyApi
|
|
).process()
|
|
}
|
|
|
|
@get:OutputDirectory
|
|
val generatedSrcMainDirectory: File
|
|
get() = buildDirectory.resolve(GeneratedSrcMain)
|
|
|
|
@get:OutputDirectory
|
|
val generatedSrcAndroidTestDirectory: File
|
|
get() = buildDirectory.resolve(GeneratedSrcAndroidTest)
|
|
|
|
@get:OutputDirectory
|
|
val generatedResourceDirectory: File
|
|
get() = buildDirectory.resolve(GeneratedResource)
|
|
|
|
/**
|
|
* The action for this task
|
|
*/
|
|
@TaskAction
|
|
abstract fun run()
|
|
|
|
companion object {
|
|
/**
|
|
* Registers the core [project]. The core project contains only the icons defined in
|
|
* [androidx.compose.material.icons.generator.CoreIcons], and no tests.
|
|
*/
|
|
@JvmStatic
|
|
fun registerCoreIconProject(
|
|
project: Project,
|
|
libraryExtension: LibraryExtension,
|
|
isMpp: Boolean
|
|
) {
|
|
if (isMpp) {
|
|
CoreIconGenerationTask.register(project, null)
|
|
} else {
|
|
libraryExtension.libraryVariants.all { variant ->
|
|
CoreIconGenerationTask.register(project, variant)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers the extended [project]. The core project contains all icons except for the
|
|
* icons defined in [androidx.compose.material.icons.generator.CoreIcons], as well as a
|
|
* bitmap comparison test for every icon in both the core and extended project.
|
|
*/
|
|
@JvmStatic
|
|
fun registerExtendedIconThemeProject(
|
|
project: Project,
|
|
libraryExtension: LibraryExtension,
|
|
isMpp: Boolean
|
|
) {
|
|
if (isMpp) {
|
|
ExtendedIconGenerationTask.register(project, null)
|
|
} else {
|
|
libraryExtension.libraryVariants.all { variant ->
|
|
ExtendedIconGenerationTask.register(project, variant)
|
|
}
|
|
}
|
|
|
|
// b/175401659 - disable lint as it takes a long time, and most errors should
|
|
// be caught by lint on material-icons-core anyway
|
|
project.afterEvaluate {
|
|
project.tasks.named("lintAnalyzeDebug") { t ->
|
|
t.enabled = false
|
|
}
|
|
project.tasks.named("lintDebug") { t ->
|
|
t.enabled = false
|
|
}
|
|
}
|
|
}
|
|
|
|
@JvmStatic
|
|
fun registerExtendedIconMainProject(
|
|
project: Project,
|
|
libraryExtension: LibraryExtension
|
|
) {
|
|
libraryExtension.testVariants.all { variant ->
|
|
IconTestingGenerationTask.register(project, variant)
|
|
}
|
|
}
|
|
|
|
const val GeneratedSrcMain = "src/commonMain/kotlin"
|
|
|
|
const val GeneratedSrcAndroidTest = "src/androidAndroidTest/kotlin"
|
|
|
|
const val GeneratedResource = "generatedIcons/res"
|
|
}
|
|
}
|
|
|
|
// Path to the generator project
|
|
private const val GeneratorProject = ":compose:material:material:icons:generator"
|
|
|
|
/**
|
|
* Registers a new [T] in [this], and sets [IconGenerationTask.buildDirectory] depending on
|
|
* [variant].
|
|
*
|
|
* @param variant the [com.android.build.gradle.api.BaseVariant] to associate this task with, or
|
|
* `null` if this task does not change between variants.
|
|
* @return a [Pair] of the created [TaskProvider] of [T] of [IconGenerationTask], and the [File]
|
|
* for the directory that files will be generated to
|
|
*/
|
|
@Suppress("DEPRECATION") // BaseVariant
|
|
fun <T : IconGenerationTask> Project.registerGenerationTask(
|
|
taskName: String,
|
|
taskClass: Class<T>,
|
|
variant: com.android.build.gradle.api.BaseVariant? = null
|
|
): Pair<TaskProvider<T>, File> {
|
|
val variantName = variant?.name ?: "allVariants"
|
|
|
|
val themeName = if (project.name.contains("material-icons-extended-")) {
|
|
project.name.replace("material-icons-extended-", "")
|
|
} else {
|
|
null
|
|
}
|
|
|
|
val buildDirectory = project.buildDir.resolve("generatedIcons/$variantName")
|
|
|
|
return tasks.register("$taskName${variantName.capitalize(Locale.getDefault())}", taskClass) {
|
|
it.themeName = themeName
|
|
it.buildDirectory = buildDirectory
|
|
} to buildDirectory
|
|
}
|
|
|
|
fun Project.getMultiplatformSourceSet(name: String): KotlinSourceSet {
|
|
val sourceSet = project.multiplatformExtension!!.sourceSets.find { it.name == name }
|
|
return requireNotNull(sourceSet) {
|
|
"No source sets found matching $name"
|
|
}
|
|
}
|
|
|
|
private val Project.multiplatformExtension
|
|
get() = extensions.findByType(KotlinMultiplatformExtension::class.java)
|