Java tutorial
/* * Copyright (C) 2014 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.model; import static com.android.build.gradle.model.AndroidComponentModelPlugin.COMPONENT_NAME; import com.android.build.gradle.internal.NdkHandler; import com.android.build.gradle.internal.NdkOptionsHelper; import com.android.build.gradle.internal.ProductFlavorCombo; import com.android.build.gradle.internal.core.Abi; import com.android.build.gradle.internal.scope.VariantScope; import com.android.build.gradle.managed.BuildType; import com.android.build.gradle.managed.NdkConfig; import com.android.build.gradle.managed.ProductFlavor; import com.android.build.gradle.ndk.internal.NdkConfiguration; import com.android.build.gradle.ndk.internal.NdkExtensionConvention; import com.android.build.gradle.ndk.internal.NdkNamingScheme; import com.android.build.gradle.ndk.internal.ToolchainConfiguration; import com.android.builder.core.BuilderConstants; import com.android.builder.core.VariantConfiguration; import com.google.common.base.Predicate; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Iterables; import org.gradle.api.Action; import org.gradle.api.BuildableModelElement; import org.gradle.api.InvalidUserDataException; import org.gradle.api.Plugin; import org.gradle.api.Project; import org.gradle.api.Task; import org.gradle.api.internal.project.ProjectIdentifier; import org.gradle.api.specs.Spec; import org.gradle.api.tasks.TaskContainer; import org.gradle.language.c.plugins.CPlugin; import org.gradle.language.cpp.plugins.CppPlugin; import org.gradle.model.Defaults; import org.gradle.model.Finalize; import org.gradle.model.Model; import org.gradle.model.ModelMap; import org.gradle.model.Mutate; import org.gradle.model.Path; import org.gradle.model.RuleSource; import org.gradle.model.Validate; import org.gradle.nativeplatform.BuildTypeContainer; import org.gradle.nativeplatform.FlavorContainer; import org.gradle.nativeplatform.NativeBinarySpec; import org.gradle.nativeplatform.NativeLibraryBinarySpec; import org.gradle.nativeplatform.NativeLibrarySpec; import org.gradle.nativeplatform.SharedLibraryBinarySpec; import org.gradle.nativeplatform.toolchain.NativeToolChainRegistry; import org.gradle.platform.base.BinaryContainer; import org.gradle.platform.base.BinarySpec; import org.gradle.platform.base.ComponentSpecContainer; import org.gradle.platform.base.PlatformContainer; import org.gradle.platform.base.binary.BaseBinarySpec; import java.io.File; import java.util.Collection; import java.util.Collections; import java.util.List; /** * Plugin for Android NDK applications. */ public class NdkComponentModelPlugin implements Plugin<Project> { private Project project; @Override public void apply(Project project) { this.project = project; project.getPluginManager().apply(AndroidComponentModelPlugin.class); project.getPluginManager().apply(CPlugin.class); project.getPluginManager().apply(CppPlugin.class); } @SuppressWarnings({ "MethodMayBeStatic", "unused" }) public static class Rules extends RuleSource { @Mutate public void initializeNdkConfig(@Path("android.ndk") NdkConfig ndk) { NdkOptionsHelper.init(ndk); ndk.setModuleName(""); ndk.setToolchain(""); ndk.setToolchainVersion(""); ndk.setStl(""); ndk.setRenderscriptNdkMode(false); } @Finalize public void setDefaultNdkExtensionValue(@Path("android.ndk") NdkConfig ndkConfig) { NdkExtensionConvention.setExtensionDefault(ndkConfig); } @Validate public void checkNdkDir(NdkHandler ndkHandler, @Path("android.ndk") NdkConfig ndkConfig) { if (!ndkConfig.getModuleName().isEmpty() && !ndkHandler.isNdkDirConfigured()) { throw new InvalidUserDataException("NDK location not found. Define location with ndk.dir in the " + "local.properties file or with an ANDROID_NDK_HOME environment " + "variable."); } if (ndkHandler.isNdkDirConfigured()) { if (!ndkHandler.getNdkDirectory().exists()) { throw new InvalidUserDataException( "Specified NDK location does not exists. Please ensure ndk.dir in " + "local.properties file or ANDROID_NDK_HOME is configured " + "correctly."); } } } @Mutate public void addDefaultNativeSourceSet(@Path("android.sources") AndroidComponentModelSourceSet sources) { sources.addDefaultSourceSet("jni", AndroidLanguageSourceSet.class); } @Model(ModelConstants.NDK_HANDLER) public NdkHandler ndkHandler(ProjectIdentifier projectId, @Path("android.compileSdkVersion") String compileSdkVersion, @Path("android.ndk") NdkConfig ndkConfig) { while (projectId.getParentIdentifier() != null) { projectId = projectId.getParentIdentifier(); } return new NdkHandler(projectId.getProjectDir(), compileSdkVersion, ndkConfig.getToolchain(), ndkConfig.getToolchainVersion()); } @Defaults public void initBuildTypeNdk(@Path("android.buildTypes") ModelMap<BuildType> buildTypes) { buildTypes.beforeEach(new Action<BuildType>() { @Override public void execute(BuildType buildType) { NdkOptionsHelper.init(buildType.getNdk()); } }); buildTypes.named(BuilderConstants.DEBUG, new Action<BuildType>() { @Override public void execute(BuildType buildType) { if (buildType.getNdk().getDebuggable() == null) { buildType.getNdk().setDebuggable(true); } } }); } @Defaults public void initProductFlavorNdk(@Path("android.productFlavors") ModelMap<ProductFlavor> productFlavors) { productFlavors.beforeEach(new Action<ProductFlavor>() { @Override public void execute(ProductFlavor productFlavor) { NdkOptionsHelper.init(productFlavor.getNdk()); } }); } @Mutate public void createAndroidPlatforms(PlatformContainer platforms, NdkHandler ndkHandler) { if (!ndkHandler.isNdkDirConfigured()) { return; } // Create android platforms. ToolchainConfiguration.configurePlatforms(platforms, ndkHandler); } @Mutate public void createToolchains(NativeToolChainRegistry toolchainRegistry, @Path("android.ndk") NdkConfig ndkConfig, NdkHandler ndkHandler) { if (!ndkHandler.isNdkDirConfigured()) { return; } // Create toolchain for each ABI. ToolchainConfiguration.configureToolchain(toolchainRegistry, ndkConfig.getToolchain(), ndkHandler); } @Mutate public void createNativeBuildTypes(BuildTypeContainer nativeBuildTypes, @Path("android.buildTypes") ModelMap<BuildType> androidBuildTypes) { for (BuildType buildType : androidBuildTypes.values()) { nativeBuildTypes.maybeCreate(buildType.getName()); } } @Mutate public void createNativeFlavors(FlavorContainer nativeFlavors, List<ProductFlavorCombo<ProductFlavor>> androidFlavorGroups) { if (androidFlavorGroups.isEmpty()) { // Create empty native flavor to override Gradle's default name. nativeFlavors.maybeCreate(""); } else { for (ProductFlavorCombo group : androidFlavorGroups) { nativeFlavors.maybeCreate(group.getName()); } } } @Mutate public void createNativeLibrary(final ComponentSpecContainer specs, @Path("android.ndk") final NdkConfig ndkConfig, final NdkHandler ndkHandler, @Path("android.sources") final AndroidComponentModelSourceSet sources, @Path("buildDir") final File buildDir) { if (!ndkHandler.isNdkDirConfigured()) { return; } if (!ndkConfig.getModuleName().isEmpty()) { specs.create(ndkConfig.getModuleName(), NativeLibrarySpec.class, new Action<NativeLibrarySpec>() { @Override public void execute(final NativeLibrarySpec nativeLib) { ((DefaultAndroidComponentSpec) specs.get(COMPONENT_NAME)).setNativeLibrary(nativeLib); NdkConfiguration.configureProperties(nativeLib, sources, buildDir, ndkHandler); } }); DefaultAndroidComponentSpec androidSpecs = (DefaultAndroidComponentSpec) specs.get(COMPONENT_NAME); androidSpecs.setNativeLibrary((NativeLibrarySpec) specs.get(ndkConfig.getModuleName())); } } @Mutate public void createAdditionalTasksForNatives(final ModelMap<Task> tasks, ModelMap<AndroidComponentSpec> specs, @Path("android.ndk") final NdkConfig ndkConfig, final NdkHandler ndkHandler, BinaryContainer binaries, @Path("buildDir") final File buildDir) { if (!ndkHandler.isNdkDirConfigured()) { return; } final DefaultAndroidComponentSpec androidSpec = (DefaultAndroidComponentSpec) specs.get(COMPONENT_NAME); if (androidSpec.getNativeLibrary() != null) { binaries.withType(DefaultAndroidBinary.class, new Action<DefaultAndroidBinary>() { @Override public void execute(DefaultAndroidBinary binary) { for (NativeBinarySpec nativeBinary : binary.getNativeBinaries()) { NdkConfiguration.createTasks(tasks, (SharedLibraryBinarySpec) nativeBinary, buildDir, binary.getMergedNdkConfig(), ndkHandler); } } }); } } @Mutate public void configureNativeBinary(BinaryContainer binaries, ComponentSpecContainer specs, @Path("android.ndk") final NdkConfig ndkConfig, @Path("buildDir") final File buildDir, final NdkHandler ndkHandler) { if (!ndkConfig.getModuleName().isEmpty()) { final NativeLibrarySpec library = specs.withType(NativeLibrarySpec.class) .get(ndkConfig.getModuleName()); binaries.withType(DefaultAndroidBinary.class, new Action<DefaultAndroidBinary>() { @Override public void execute(DefaultAndroidBinary binary) { binary.computeMergedNdk(ndkConfig, binary.getProductFlavors(), binary.getBuildType()); Collection<SharedLibraryBinarySpec> nativeBinaries = getNativeBinaries(library, binary.getBuildType(), binary.getProductFlavors()); for (SharedLibraryBinarySpec nativeBin : nativeBinaries) { if (binary.getMergedNdkConfig().getAbiFilters().isEmpty() || binary.getMergedNdkConfig() .getAbiFilters().contains(nativeBin.getTargetPlatform().getName())) { NdkConfiguration.configureBinary(nativeBin, buildDir, binary.getMergedNdkConfig(), ndkHandler); binary.getNativeBinaries().add(nativeBin); } } } }); } } @Finalize public void attachNativeTasksToAndroidBinary(ModelMap<AndroidBinary> binaries) { binaries.afterEach(new Action<AndroidBinary>() { @Override public void execute(AndroidBinary androidBinary) { DefaultAndroidBinary binary = (DefaultAndroidBinary) androidBinary; for (NativeLibraryBinarySpec nativeBinary : binary.getNativeBinaries()) { if (binary.getTargetAbi().isEmpty() || binary.getTargetAbi().contains(nativeBinary.getTargetPlatform().getName())) { binary.getBuildTask().dependsOn(NdkNamingScheme.getNdkBuildTaskName(nativeBinary)); } } } }); } @Mutate public void removeNativeBinaryFromAssembleTask(ModelMap<AndroidComponentSpec> components) { // Setting each native binary to not buildable to prevent the native tasks to be // automatically added to the "assemble" task. components.afterEach(new Action<AndroidComponentSpec>() { @Override public void execute(AndroidComponentSpec spec) { NativeLibrarySpec nativeLibrary = ((DefaultAndroidComponentSpec) spec).getNativeLibrary(); if (nativeLibrary != null) { nativeLibrary.getBinaries().afterEach(new Action<BinarySpec>() { @Override public void execute(BinarySpec binary) { ((BaseBinarySpec) binary).setBuildable(false); } }); } } }); } /** * Remove unintended tasks created by Gradle native plugin from task list. * * Gradle native plugins creates static library tasks automatically. This method removes * them to avoid cluttering the task list. */ @Mutate public void hideNativeTasks(TaskContainer tasks, BinaryContainer binaries) { // Gradle do not support a way to remove created tasks. The best workaround is to clear the // group of the task and have another task depends on it. Therefore, we have to create // a dummy task to depend on all the tasks that we do not want to show up on the task // list. The dummy task dependsOn itself, effectively making it non-executable and // invisible unless the --all option is use. final Task nonExecutableTask = tasks.create("nonExecutableTask"); nonExecutableTask.dependsOn(nonExecutableTask); nonExecutableTask.setDescription("Dummy task to hide other unwanted tasks in the task list."); binaries.withType(NativeLibraryBinarySpec.class, new Action<NativeLibraryBinarySpec>() { @Override public void execute(NativeLibraryBinarySpec binary) { Task buildTask = binary.getBuildTask(); nonExecutableTask.dependsOn(buildTask); buildTask.setGroup(null); } }); } } public static void configureScopeForNdk(VariantScope scope) { VariantConfiguration config = scope.getVariantConfiguration(); ImmutableSet.Builder<File> builder = ImmutableSet.builder(); for (Abi abi : NdkHandler.getAbiList()) { scope.addNdkDebuggableLibraryFolders(abi, new File(scope.getGlobalScope().getBuildDir(), NdkNamingScheme.getDebugLibraryDirectoryName( config.getBuildType().getName(), config.getFlavorName(), abi.getName()))); // Return the parent directory of the binaries' output. // If output directory is "/path/to/lib/platformName". We want to return // "/path/to/lib". builder.add(new File(scope.getGlobalScope().getBuildDir(), NdkNamingScheme .getOutputDirectoryName(config.getBuildType().getName(), config.getFlavorName(), abi.getName())) .getParentFile()); } scope.setNdkSoFolder(builder.build()); } private static Collection<SharedLibraryBinarySpec> getNativeBinaries(NativeLibrarySpec library, final BuildType buildType, final List<ProductFlavor> productFlavors) { final ProductFlavorCombo<ProductFlavor> flavorGroup = new ProductFlavorCombo<ProductFlavor>(productFlavors); return ImmutableList .copyOf(Iterables.filter(library.getBinaries().withType(SharedLibraryBinarySpec.class).values(), new Predicate<SharedLibraryBinarySpec>() { @Override public boolean apply(SharedLibraryBinarySpec binary) { return binary.getBuildType().getName().equals(buildType.getName()) && (binary.getFlavor().getName().equals(flavorGroup.getName()) || (productFlavors.isEmpty() && binary.getFlavor().getName().equals("default"))); } })); } /** * Return library binaries for a VariantConfiguration. */ public Collection<? extends BuildableModelElement> getBinaries(final VariantConfiguration variantConfig) { if (variantConfig.getType().isForTesting()) { // Do not return binaries for test variants as test source set is not supported at the // moment. return Collections.emptyList(); } BinaryContainer binaries = (BinaryContainer) project.getExtensions().getByName("binaries"); return binaries.withType(AndroidBinary.class).matching(new Spec<AndroidBinary>() { @Override public boolean isSatisfiedBy(AndroidBinary binary) { return (binary.getName().equals(variantConfig.getFullName())); } }); } }