| /* |
| * Copyright (C) 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 com.android.build.gradle.internal.tasks |
| |
| import com.android.build.api.component.impl.TestComponentImpl |
| import com.android.build.api.component.impl.TestComponentPropertiesImpl |
| import com.android.build.api.variant.impl.ApplicationVariantImpl |
| import com.android.build.api.variant.impl.ApplicationVariantPropertiesImpl |
| import com.android.build.gradle.BaseExtension |
| import com.android.build.gradle.internal.AbstractAppTaskManager |
| import com.android.build.gradle.internal.TaskManager |
| import com.android.build.gradle.internal.component.ApkCreationConfig |
| import com.android.build.gradle.internal.dsl.BaseAppModuleExtension |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts.PublishedConfigType |
| import com.android.build.gradle.internal.scope.GlobalScope |
| import com.android.build.gradle.internal.tasks.databinding.DataBindingExportFeatureApplicationIdsTask |
| import com.android.build.gradle.internal.tasks.factory.dependsOn |
| import com.android.build.gradle.internal.tasks.featuresplit.FeatureSetMetadataWriterTask |
| import com.android.build.gradle.internal.variant.ComponentInfo |
| import com.android.build.gradle.options.BooleanOption |
| import com.android.builder.errors.IssueReporter |
| import com.android.builder.profile.Recorder |
| import com.google.common.collect.ImmutableMap |
| import org.gradle.api.Action |
| import org.gradle.api.artifacts.ArtifactView |
| import org.gradle.api.artifacts.Configuration |
| import org.gradle.api.attributes.AttributeContainer |
| import org.gradle.api.file.FileCollection |
| import java.io.File |
| import java.util.ArrayList |
| import java.util.stream.Collectors |
| |
| class ApplicationTaskManager( |
| variants: List<ComponentInfo<ApplicationVariantImpl, ApplicationVariantPropertiesImpl>>, |
| testComponents: List<ComponentInfo<TestComponentImpl<out TestComponentPropertiesImpl>, TestComponentPropertiesImpl>>, |
| hasFlavors: Boolean, |
| globalScope: GlobalScope, |
| extension: BaseExtension, |
| recorder: Recorder |
| ) : AbstractAppTaskManager<ApplicationVariantImpl, ApplicationVariantPropertiesImpl>( |
| variants, |
| testComponents, |
| hasFlavors, |
| globalScope, |
| extension, |
| recorder |
| ) { |
| |
| override fun doCreateTasksForVariant( |
| variant: ComponentInfo<ApplicationVariantImpl, ApplicationVariantPropertiesImpl>, |
| allVariants: MutableList<ComponentInfo<ApplicationVariantImpl, ApplicationVariantPropertiesImpl>> |
| ) { |
| createCommonTasks(variant, allVariants) |
| |
| val variantProperties = variant.properties |
| |
| // Base feature specific tasks. |
| taskFactory.register(FeatureSetMetadataWriterTask.CreationAction(variantProperties)) |
| |
| createValidateSigningTask(variantProperties) |
| // Add a task to produce the signing config file. |
| // Add a task to produce the signing config file. |
| taskFactory.register(SigningConfigWriterTask.CreationAction(variantProperties)) |
| |
| if ((extension as BaseAppModuleExtension).assetPacks.isNotEmpty()) { |
| createAssetPackTasks(variantProperties) |
| } |
| |
| if (variantProperties.buildFeatures.dataBinding |
| && variantProperties.globalScope.hasDynamicFeatures()) { |
| // Create a task that will package the manifest ids(the R file packages) of all |
| // features into a file. This file's path is passed into the Data Binding annotation |
| // processor which uses it to known about all available features. |
| // |
| // <p>see: {@link TaskManager#setDataBindingAnnotationProcessorParams(VariantScope)} |
| taskFactory.register( |
| DataBindingExportFeatureApplicationIdsTask.CreationAction(variantProperties) |
| ) |
| } |
| |
| createDynamicBundleTask(variant) |
| |
| handleMicroApp(variantProperties) |
| |
| // do not publish the APK(s) if there are dynamic feature. |
| // do not publish the APK(s) if there are dynamic feature. |
| if (!variantProperties.globalScope.hasDynamicFeatures()) { |
| createSoftwareComponent( |
| variantProperties, |
| "_apk", |
| PublishedConfigType.APK_PUBLICATION |
| ) |
| } |
| createSoftwareComponent(variantProperties, "_aab", PublishedConfigType.AAB_PUBLICATION) |
| } |
| |
| /** Configure variantData to generate embedded wear application. */ |
| private fun handleMicroApp(variantProperties: ApplicationVariantPropertiesImpl) { |
| val variantDslInfo = variantProperties.variantDslInfo |
| val variantType = variantProperties.variantType |
| if (variantType.isBaseModule) { |
| val unbundledWearApp: Boolean? = variantDslInfo.isWearAppUnbundled |
| if (unbundledWearApp != true && variantDslInfo.isEmbedMicroApp) { |
| val wearApp = |
| variantProperties.variantDependencies.wearAppConfiguration |
| ?: error("Wear app with no wearApp configuration") |
| if (!wearApp.allDependencies.isEmpty()) { |
| val setApkArtifact = |
| Action { container: AttributeContainer -> |
| container.attribute( |
| AndroidArtifacts.ARTIFACT_TYPE, |
| AndroidArtifacts.ArtifactType.APK.type |
| ) |
| } |
| val files = wearApp.incoming |
| .artifactView { config: ArtifactView.ViewConfiguration -> |
| config.attributes( |
| setApkArtifact |
| ) |
| } |
| .files |
| createGenerateMicroApkDataTask(variantProperties, files) |
| } |
| } else { |
| if (unbundledWearApp == true) { |
| createGenerateMicroApkDataTask(variantProperties) |
| } |
| } |
| } |
| } |
| |
| /** |
| * Creates the task that will handle micro apk. |
| * |
| * |
| * New in 2.2, it now supports the unbundled mode, in which the apk is not bundled anymore, |
| * but we still have an XML resource packaged, and a custom entry in the manifest. This is |
| * triggered by passing a null [Configuration] object. |
| * |
| * @param variantProperties the variant scope |
| * @param config an optional Configuration object. if non null, this will embed the micro apk, |
| * if null this will trigger the unbundled mode. |
| */ |
| private fun createGenerateMicroApkDataTask( |
| variantProperties: ApplicationVariantPropertiesImpl, |
| config: FileCollection? = null |
| ) { |
| val generateMicroApkTask = |
| taskFactory.register( |
| GenerateApkDataTask.CreationAction( |
| variantProperties, |
| config |
| ) |
| ) |
| // the merge res task will need to run after this one. |
| variantProperties.taskContainer.resourceGenTask.dependsOn( |
| generateMicroApkTask |
| ) |
| } |
| |
| private fun createAssetPackTasks(variantProperties: ApplicationVariantPropertiesImpl) { |
| val depHandler = project.dependencies |
| val notFound: MutableList<String> = |
| ArrayList() |
| val assetPackFilesConfiguration = |
| project.configurations.maybeCreate("assetPackFiles") |
| val assetPackManifestConfiguration = |
| project.configurations.maybeCreate("assetPackManifest") |
| val assetPacks: Set<String> = |
| (extension as BaseAppModuleExtension).assetPacks |
| for (assetPack in assetPacks) { |
| if (project.findProject(assetPack) != null) { |
| val filesDependency: Map<String, String?> = |
| ImmutableMap.of<String, String?>( |
| "path", |
| assetPack, |
| "configuration", |
| "packElements" |
| ) |
| depHandler.add("assetPackFiles", depHandler.project(filesDependency)) |
| val manifestDependency: Map<String, String?> = |
| ImmutableMap.of<String, String?>( |
| "path", |
| assetPack, |
| "configuration", |
| "manifestElements" |
| ) |
| depHandler.add("assetPackManifest", depHandler.project(manifestDependency)) |
| variantProperties.needAssetPackTasks.set(true) |
| } else { |
| notFound.add(assetPack) |
| } |
| } |
| if (variantProperties.needAssetPackTasks.get()) { |
| val assetPackManifest = |
| assetPackManifestConfiguration.incoming.files |
| val assetFiles = assetPackFilesConfiguration.incoming.files |
| taskFactory.register( |
| ProcessAssetPackManifestTask.CreationAction( |
| variantProperties, |
| assetPackManifest, |
| assetPacks |
| .stream() |
| .map { assetPackName: String -> |
| assetPackName.replace( |
| ":", |
| File.separator |
| ) |
| } |
| .collect(Collectors.toSet()) |
| ) |
| ) |
| taskFactory.register( |
| LinkManifestForAssetPackTask.CreationAction( |
| variantProperties |
| ) |
| ) |
| taskFactory.register( |
| AssetPackPreBundleTask.CreationAction( |
| variantProperties, |
| assetFiles |
| ) |
| ) |
| } |
| if (!notFound.isEmpty()) { |
| variantProperties.services.issueReporter.reportError( |
| IssueReporter.Type.GENERIC, |
| "Unable to find matching projects for Asset Packs: $notFound" |
| ) |
| } |
| } |
| |
| private fun createDynamicBundleTask(variant: ComponentInfo<ApplicationVariantImpl, ApplicationVariantPropertiesImpl>) { |
| val variantProperties = variant.properties |
| |
| // If namespaced resources are enabled, LINKED_RES_FOR_BUNDLE is not generated, |
| // and the bundle can't be created. For now, just don't add the bundle task. |
| // TODO(b/111168382): Remove this |
| if (variantProperties.globalScope.extension.aaptOptions.namespaced) { |
| return |
| } |
| |
| taskFactory.register( |
| PerModuleBundleTask.CreationAction( |
| variantProperties, |
| TaskManager.packagesCustomClassDependencies(variantProperties) |
| ) |
| ) |
| |
| val debuggable = variant.variant.debuggable |
| val includeSdkInfoInApk = variant.variant.dependenciesInfo.includeInApk |
| val includeSdkInfoInBundle = variant.variant.dependenciesInfo.includeInBundle |
| if (!debuggable) { |
| taskFactory.register(PerModuleReportDependenciesTask.CreationAction(variantProperties)) |
| } |
| if (variantProperties.variantType.isBaseModule) { |
| taskFactory.register(ParseIntegrityConfigTask.CreationAction(variantProperties)) |
| taskFactory.register(PackageBundleTask.CreationAction(variantProperties)) |
| taskFactory.register(FinalizeBundleTask.CreationAction(variantProperties)) |
| if (!debuggable) { |
| if (includeSdkInfoInBundle) { |
| taskFactory.register(BundleReportDependenciesTask.CreationAction(variantProperties)) |
| } |
| if (includeSdkInfoInApk && variantProperties.services |
| .projectOptions[BooleanOption.INCLUDE_DEPENDENCY_INFO_IN_APKS]) { |
| taskFactory.register(SdkDependencyDataGeneratorTask.CreationAction(variantProperties)) |
| } |
| } |
| taskFactory.register(BundleToApkTask.CreationAction(variantProperties)) |
| taskFactory.register(BundleToStandaloneApkTask.CreationAction(variantProperties)) |
| taskFactory.register(ExtractApksTask.CreationAction(variantProperties)) |
| val mergeNativeDebugMetadataTask = |
| taskFactory.register(MergeNativeDebugMetadataTask.CreationAction(variantProperties)) |
| variantProperties.taskContainer.assembleTask.dependsOn(mergeNativeDebugMetadataTask) |
| } |
| } |
| |
| private fun createSoftwareComponent( |
| variantProperties: ApplicationVariantPropertiesImpl, |
| suffix: String, |
| publication: PublishedConfigType |
| ) { |
| val component = globalScope.componentFactory.adhoc(variantProperties.name + suffix) |
| val config = variantProperties.variantDependencies.getElements(publication)!! |
| component.addVariantsFromConfiguration(config) { } |
| project.components.add(component) |
| } |
| |
| override fun createInstallTask(creationConfig: ApkCreationConfig) { |
| if (extension is BaseAppModuleExtension && extension.dynamicFeatures.isEmpty()) { |
| // no dynamic features means we can just use the standard install task |
| super.createInstallTask(creationConfig) |
| } else { |
| // need to install via bundle |
| taskFactory.register(InstallVariantViaBundleTask.CreationAction(creationConfig)) |
| } |
| } |
| |
| } |
