| /* |
| * Copyright (C) 2017 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.res |
| |
| import com.android.SdkConstants |
| import com.android.build.api.component.impl.ComponentPropertiesImpl |
| import com.android.build.api.variant.FilterConfiguration |
| import com.android.build.api.variant.impl.BuiltArtifactImpl |
| import com.android.build.api.variant.impl.BuiltArtifactsImpl |
| import com.android.build.api.variant.impl.BuiltArtifactsLoaderImpl |
| import com.android.build.gradle.internal.profile.ProfileAwareWorkAction |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts.ArtifactScope.ALL |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts.ConsumedConfigType.COMPILE_CLASSPATH |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts.ConsumedConfigType.RUNTIME_CLASSPATH |
| import com.android.build.gradle.internal.scope.InternalArtifactType |
| import com.android.build.gradle.internal.tasks.factory.VariantTaskCreationAction |
| import com.android.build.gradle.internal.utils.fromDisallowChanges |
| import com.android.build.gradle.internal.utils.setDisallowChanges |
| import com.android.build.gradle.options.BooleanOption |
| import com.android.build.gradle.tasks.ProcessAndroidResources |
| import com.android.builder.symbols.processLibraryMainSymbolTable |
| import com.android.ide.common.symbols.IdProvider |
| import com.android.ide.common.symbols.SymbolIo |
| import com.android.ide.common.symbols.SymbolTable |
| import java.io.File |
| import java.io.IOException |
| import javax.inject.Inject |
| import org.gradle.api.file.ConfigurableFileCollection |
| import org.gradle.api.file.RegularFileProperty |
| import org.gradle.api.provider.Property |
| import org.gradle.api.tasks.CacheableTask |
| import org.gradle.api.tasks.Input |
| import org.gradle.api.tasks.InputFile |
| import org.gradle.api.tasks.InputFiles |
| import org.gradle.api.tasks.Internal |
| import org.gradle.api.tasks.Optional |
| import org.gradle.api.tasks.OutputFile |
| import org.gradle.api.tasks.PathSensitive |
| import org.gradle.api.tasks.PathSensitivity |
| import org.gradle.api.tasks.TaskProvider |
| |
| |
| @CacheableTask |
| abstract class GenerateLibraryRFileTask : ProcessAndroidResources() { |
| |
| @get:OutputFile |
| abstract val rClassOutputJar: RegularFileProperty |
| |
| @Internal // rClassOutputJar is already marked as @OutputFile |
| override fun getSourceOutputDir(): File? = rClassOutputJar.get().asFile |
| |
| // used by Butterknife |
| @Suppress("unused") |
| @Internal |
| fun getTextSymbolOutputFile(): File { |
| return textSymbolOutputFileProperty.get().asFile |
| } |
| |
| @get:OutputFile |
| @get:Optional |
| abstract val textSymbolOutputFileProperty: RegularFileProperty |
| |
| @get:OutputFile |
| @get:Optional |
| abstract val symbolsWithPackageNameOutputFile: RegularFileProperty |
| |
| @get:InputFiles |
| @get:PathSensitive(PathSensitivity.NONE) abstract val dependencies: ConfigurableFileCollection |
| |
| @get:Input |
| abstract val packageForR: Property<String> |
| |
| @get:InputFiles |
| @get:PathSensitive(PathSensitivity.NAME_ONLY) |
| abstract val platformAttrRTxt: ConfigurableFileCollection |
| |
| @get:InputFile |
| @get:PathSensitive(PathSensitivity.RELATIVE) |
| abstract val localResourcesFile: RegularFileProperty |
| |
| @get:Input |
| abstract val nonTransitiveRClass: Property<Boolean> |
| |
| @get:Input |
| abstract val compileClasspathLibraryRClasses: Property<Boolean> |
| |
| @get:Input |
| abstract val useConstantIds: Property<Boolean> |
| |
| @Throws(IOException::class) |
| override fun doFullTaskAction() { |
| val manifestBuiltArtifacts = BuiltArtifactsLoaderImpl().load(manifestFiles) |
| ?: throw RuntimeException("Cannot load generated manifests, file a bug") |
| val manifest = File(chooseOutput(manifestBuiltArtifacts).outputFile) |
| |
| workerExecutor.noIsolation().submit(GenerateLibRFileRunnable::class.java) { |
| it.initializeFromAndroidVariantTask(this) |
| it.localResourcesFile.set(localResourcesFile) |
| it.manifest.set(manifest) |
| it.androidJar.from(platformAttrRTxt) |
| it.dependencies.from(dependencies) |
| it.packageForR.set(packageForR.get()) |
| it.rClassOutputJar.set(rClassOutputJar) |
| it.textSymbolOutputFile.set(textSymbolOutputFileProperty) |
| it.nonTransitiveRClass.set(nonTransitiveRClass.get()) |
| it.compileClasspathLibraryRClasses.set(compileClasspathLibraryRClasses.get()) |
| it.symbolsWithPackageNameOutputFile.set(symbolsWithPackageNameOutputFile) |
| it.useConstantIds.set(useConstantIds.get()) |
| } |
| } |
| |
| private fun chooseOutput(manifestBuiltArtifacts: BuiltArtifactsImpl): BuiltArtifactImpl = |
| manifestBuiltArtifacts.elements |
| .firstOrNull() { output -> output.getFilter(FilterConfiguration.FilterType.DENSITY) == null } |
| ?: throw RuntimeException("No non-density apk found") |
| |
| abstract class GenerateLibRFileParams : ProfileAwareWorkAction.Parameters() { |
| abstract val localResourcesFile: RegularFileProperty |
| abstract val manifest: RegularFileProperty |
| abstract val androidJar: ConfigurableFileCollection |
| abstract val dependencies: ConfigurableFileCollection |
| abstract val packageForR: Property<String> |
| abstract val rClassOutputJar: RegularFileProperty |
| abstract val textSymbolOutputFile: RegularFileProperty |
| abstract val nonTransitiveRClass: Property<Boolean> |
| abstract val compileClasspathLibraryRClasses: Property<Boolean> |
| abstract val symbolsWithPackageNameOutputFile: RegularFileProperty |
| abstract val useConstantIds: Property<Boolean> |
| } |
| |
| abstract class GenerateLibRFileRunnable @Inject constructor() : |
| ProfileAwareWorkAction<GenerateLibRFileParams>() { |
| override fun run() { |
| val androidAttrSymbol = getAndroidAttrSymbols() |
| |
| val symbolTable = SymbolIo.readRDef(parameters.localResourcesFile.asFile.get().toPath()) |
| |
| val idProvider = |
| if (parameters.useConstantIds.get()) { |
| IdProvider.constant() |
| } else { |
| IdProvider.sequential() |
| } |
| processLibraryMainSymbolTable( |
| librarySymbols = symbolTable, |
| libraries = parameters.dependencies.files, |
| mainPackageName = parameters.packageForR.get(), |
| manifestFile = parameters.manifest.asFile.get(), |
| rClassOutputJar = parameters.rClassOutputJar.asFile.orNull, |
| symbolFileOut = parameters.textSymbolOutputFile.asFile.orNull, |
| platformSymbols = androidAttrSymbol, |
| nonTransitiveRClass = parameters.nonTransitiveRClass.get(), |
| generateDependencyRClasses = !parameters.compileClasspathLibraryRClasses.get(), |
| idProvider = idProvider |
| ) |
| |
| parameters.symbolsWithPackageNameOutputFile.asFile.orNull?.let { |
| SymbolIo.writeSymbolListWithPackageName( |
| parameters.textSymbolOutputFile.get().asFile.toPath(), |
| parameters.manifest.get().asFile.toPath(), |
| it.toPath() |
| ) |
| } |
| } |
| |
| private fun getAndroidAttrSymbols() = |
| if (parameters.androidJar.singleFile.exists()) |
| SymbolIo.readFromAapt(parameters.androidJar.singleFile, "android") |
| else |
| SymbolTable.builder().tablePackage("android").build() |
| } |
| |
| internal class CreationAction( |
| componentProperties: ComponentPropertiesImpl, |
| val isLibrary: Boolean) |
| : VariantTaskCreationAction<GenerateLibraryRFileTask, ComponentPropertiesImpl>(componentProperties) { |
| |
| override val name: String |
| get() = computeTaskName("generate", "RFile") |
| override val type: Class<GenerateLibraryRFileTask> |
| get() = GenerateLibraryRFileTask::class.java |
| |
| override fun handleProvider( |
| taskProvider: TaskProvider<GenerateLibraryRFileTask> |
| ) { |
| super.handleProvider(taskProvider) |
| creationConfig.taskContainer.processAndroidResTask = taskProvider |
| |
| creationConfig.artifacts.setInitialProvider( |
| taskProvider, |
| GenerateLibraryRFileTask::rClassOutputJar |
| ).withName("R.jar").on(InternalArtifactType.COMPILE_R_CLASS_JAR) |
| |
| creationConfig.artifacts.setInitialProvider( |
| taskProvider, |
| GenerateLibraryRFileTask::textSymbolOutputFileProperty |
| ).withName(SdkConstants.FN_RESOURCE_TEXT).on(InternalArtifactType.COMPILE_SYMBOL_LIST) |
| |
| // Synthetic output for AARs (see SymbolTableWithPackageNameTransform), and created in |
| // process resources for local subprojects. |
| creationConfig.artifacts.setInitialProvider( |
| taskProvider, |
| GenerateLibraryRFileTask::symbolsWithPackageNameOutputFile |
| ).withName("package-aware-r.txt").on(InternalArtifactType.SYMBOL_LIST_WITH_PACKAGE_NAME) |
| } |
| |
| override fun configure( |
| task: GenerateLibraryRFileTask |
| ) { |
| super.configure(task) |
| |
| val projectOptions = creationConfig.services.projectOptions |
| |
| task.platformAttrRTxt.fromDisallowChanges(creationConfig.globalScope.platformAttrs) |
| |
| val nonTransitiveRClass = projectOptions[BooleanOption.NON_TRANSITIVE_R_CLASS] |
| val compileClasspathLibraryRClasses = projectOptions[BooleanOption.COMPILE_CLASSPATH_LIBRARY_R_CLASSES] |
| |
| if (!nonTransitiveRClass || !compileClasspathLibraryRClasses) { |
| // We need the dependencies for generating our own R class or for generating R |
| // classes of the dependencies: |
| // * If we're creating a transitive (non-namespaced) R class, then we need the |
| // dependencies to include them in the local R class. |
| // * If we're using the runtime classpath (not compile classpath) then we need the |
| // dependencies for generating the R classes for each of them. |
| // * If both above are true then we use the dependencies for generating both the |
| // local R class and the dependencies' R classes. |
| // * The only case when we don't need the dependencies is if we are generating a |
| // namespaced (non-transitive) local R class AND we're using the compile |
| // classpath R class flow. |
| val consumedConfigType = |
| if (compileClasspathLibraryRClasses) { |
| COMPILE_CLASSPATH |
| } else { |
| RUNTIME_CLASSPATH |
| } |
| task.dependencies.from( |
| creationConfig.variantDependencies.getArtifactFileCollection( |
| consumedConfigType, |
| ALL, |
| AndroidArtifacts.ArtifactType.SYMBOL_LIST_WITH_PACKAGE_NAME |
| )) |
| } |
| |
| task.nonTransitiveRClass.set(nonTransitiveRClass) |
| task.compileClasspathLibraryRClasses.setDisallowChanges(compileClasspathLibraryRClasses) |
| task.packageForR.setDisallowChanges(creationConfig.packageName) |
| |
| creationConfig.artifacts.setTaskInputToFinalProduct( |
| InternalArtifactType.PACKAGED_MANIFESTS, task.manifestFiles) |
| |
| creationConfig.artifacts.setTaskInputToFinalProduct( |
| InternalArtifactType.MERGED_MANIFESTS, task.mergedManifestFiles) |
| |
| task.mainSplit = creationConfig.outputs.getMainSplit() |
| |
| // This task can produce R classes with either constant IDs ("0") or sequential IDs |
| // mimicking the way AAPT2 numbers IDs. If we're generating a compile time only R class |
| // (either for the small merge in app or when using compile classpath resources in libs) |
| // we want to use the constant IDs; otherwise, we will use sequential IDs. |
| // In either case, the IDs are fake, and therefore are non-final. |
| task.useConstantIds.set( |
| (projectOptions[BooleanOption.ENABLE_APP_COMPILE_TIME_R_CLASS] && !isLibrary) |
| || projectOptions[BooleanOption.COMPILE_CLASSPATH_LIBRARY_R_CLASSES]) |
| |
| creationConfig.artifacts.setTaskInputToFinalProduct( |
| InternalArtifactType.LOCAL_ONLY_SYMBOL_LIST, |
| task.localResourcesFile) |
| } |
| } |
| |
| internal class TestRuntimeStubRClassCreationAction(componentProperties: ComponentPropertiesImpl) : |
| VariantTaskCreationAction<GenerateLibraryRFileTask, ComponentPropertiesImpl>( |
| componentProperties |
| ) { |
| |
| override val name: String = computeTaskName("generate", "StubRFile") |
| override val type: Class<GenerateLibraryRFileTask> = GenerateLibraryRFileTask::class.java |
| |
| override fun handleProvider( |
| taskProvider: TaskProvider<GenerateLibraryRFileTask> |
| ) { |
| super.handleProvider(taskProvider) |
| creationConfig.artifacts.setInitialProvider( |
| taskProvider, |
| GenerateLibraryRFileTask::rClassOutputJar |
| ).withName("R.jar").on(InternalArtifactType.COMPILE_AND_RUNTIME_NOT_NAMESPACED_R_CLASS_JAR) |
| } |
| |
| override fun configure( |
| task: GenerateLibraryRFileTask |
| ) { |
| super.configure(task) |
| val projectOptions = creationConfig.services.projectOptions |
| |
| task.platformAttrRTxt.fromDisallowChanges(creationConfig.globalScope.platformAttrs) |
| |
| // We need the runtime dependencies for generating a set of consistent runtime R classes |
| // for android test, and in the case of transitive R classes, we also need them |
| // to include them in the local R class. |
| task.dependencies.fromDisallowChanges( |
| creationConfig.variantDependencies.getArtifactFileCollection( |
| RUNTIME_CLASSPATH, |
| ALL, |
| AndroidArtifacts.ArtifactType.SYMBOL_LIST_WITH_PACKAGE_NAME |
| ) |
| ) |
| |
| task.nonTransitiveRClass.setDisallowChanges(projectOptions[BooleanOption.NON_TRANSITIVE_R_CLASS]) |
| task.compileClasspathLibraryRClasses.setDisallowChanges(false) |
| task.packageForR.setDisallowChanges(creationConfig.packageName) |
| task.mainSplit = creationConfig.outputs.getMainSplit() |
| task.useConstantIds.setDisallowChanges(false) |
| |
| creationConfig.onTestedConfig { |
| it.artifacts.setTaskInputToFinalProduct( |
| InternalArtifactType.PACKAGED_MANIFESTS, task.manifestFiles |
| ) |
| |
| it.artifacts.setTaskInputToFinalProduct( |
| InternalArtifactType.LOCAL_ONLY_SYMBOL_LIST, |
| task.localResourcesFile |
| ) |
| } |
| } |
| } |
| } |
