Merge pull request #70 from gradle/tt/reduce-duplication-with-oop

Refactor to remove duplication

unified-prototype/unified-plugin/plugin-android/src/main/java/org/gradle/api/experimental/android/AbstractAndroidSoftwarePlugin.java

@@ -0,0 +1,179 @@
+package org.gradle.api.experimental.android;
+
+import com.android.build.api.dsl.*;
+import org.gradle.api.*;
+import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.experimental.android.extensions.testing.AndroidTestDependencies;
+import org.gradle.api.experimental.android.extensions.testing.TestOptions;
+import org.gradle.api.experimental.android.extensions.testing.Testing;
+import org.gradle.api.experimental.android.nia.NiaSupport;
+import org.gradle.api.provider.Property;
+import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension;
+
+import java.util.Objects;
+
+import static org.gradle.api.experimental.android.extensions.ComposeSupport.configureCompose;
+
+public abstract class AbstractAndroidSoftwarePlugin implements Plugin<Project> {
+ protected static final int DEFAULT_JDK = 11;
+ protected static final int DEFAULT_TARGET_ANDROID_SDK = 34;
+ protected static final int DEFAULT_MIN_ANDROID_SDK = 21;
+
+ protected abstract AndroidSoftware getAndroidSoftware();
+
+ public void apply(Project project) {
+ AndroidSoftware dslModel = getAndroidSoftware();
+
+ // Setup Android software conventions
+ dslModel.getJdkVersion().convention(DEFAULT_JDK);
+ dslModel.getCompileSdk().convention(DEFAULT_TARGET_ANDROID_SDK);
+ dslModel.getMinSdk().convention(DEFAULT_MIN_ANDROID_SDK); // https://developer.android.com/build/multidex#mdex-gradle
+
+ // Setup minify conventions
+ dslModel.getBuildTypes().getDebug().getMinify().getEnabled().convention(false);
+ dslModel.getBuildTypes().getRelease().getMinify().getEnabled().convention(false);
+
+ // Setup desugaring conventions and desugar automatically when JDK > 8 is targeted
+ dslModel.getCoreLibraryDesugaring().getEnabled().convention(project.provider(() -> dslModel.getJdkVersion().get() > 8));
+ dslModel.getCoreLibraryDesugaring().getLibVersion().convention("2.0.4");
+
+ // Setup Serialization conventions
+ dslModel.getKotlinSerialization().getEnabled().convention(false);
+ dslModel.getKotlinSerialization().getVersion().convention("1.6.3");
+ dslModel.getKotlinSerialization().getJsonEnabled().convention(false);
+
+ // Setup other feature extension conventions
+ dslModel.getFeature().getEnabled().convention(false);
+ dslModel.getCompose().getEnabled().convention(false);
+ dslModel.getHilt().getEnabled().convention(false);
+
+ // Setup Test Options conventions
+ dslModel.getTesting().getTestOptions().getIncludeAndroidResources().convention(false);
+ dslModel.getTesting().getTestOptions().getReturnDefaultValues().convention(false);
+ dslModel.getTesting().getJacoco().getEnabled().convention(false);
+ dslModel.getTesting().getJacoco().getVersion().convention("0.8.7");
+ }
+
+ /**
+ * Performs common dependency linking actions that do not need to occur within an afterEvaluate block.
+ */
+ @SuppressWarnings("UnstableApiUsage")
+ protected void linkCommonDependencies(AndroidSoftwareDependencies dependencies, ConfigurationContainer configurations) {
+ configurations.getByName("implementation").fromDependencyCollector(dependencies.getImplementation());
+ configurations.getByName("compileOnly").fromDependencyCollector(dependencies.getCompileOnly());
+ configurations.getByName("runtimeOnly").fromDependencyCollector(dependencies.getRuntimeOnly());
+ }
+
+ /**
+ * Performs linking actions that must occur within an afterEvaluate block.
+ */
+ protected void linkDslModelToPlugin(Project project, AndroidSoftware dslModel, CommonExtension<?, ?, ?, ?, ?, ?> android) {
+ KotlinAndroidProjectExtension kotlin = project.getExtensions().getByType(KotlinAndroidProjectExtension.class);
+ ConfigurationContainer configurations = project.getConfigurations();
+
+ // Link common properties
+ ifPresent(dslModel.getNamespace(), android::setNamespace);
+ ifPresent(dslModel.getCompileSdk(), android::setCompileSdk);
+ android.defaultConfig(defaultConfig -> {
+ ifPresent(dslModel.getMinSdk(), defaultConfig::setMinSdk);
+ return null;
+ });
+ android.compileOptions(compileOptions -> {
+ // Up to Java 11 APIs are available through desugaring
+ // https://developer.android.com/studio/write/java11-minimal-support-table
+ compileOptions.setSourceCompatibility(JavaVersion.toVersion(dslModel.getJdkVersion().get()));
+ compileOptions.setTargetCompatibility(JavaVersion.toVersion(dslModel.getJdkVersion().get()));
+ return null;
+ });
+ ifPresent(dslModel.getJdkVersion(), jdkVersion -> {
+ kotlin.jvmToolchain(jdkVersion);
+ android.getCompileOptions().setSourceCompatibility(JavaVersion.toVersion(jdkVersion));
+ android.getCompileOptions().setTargetCompatibility(JavaVersion.toVersion(jdkVersion));
+ });
+
+ // Link build types
+ AndroidSoftwareBuildTypes modelBuildType = dslModel.getBuildTypes();
+ NamedDomainObjectContainer<? extends BuildType> androidBuildTypes = android.getBuildTypes();
+ linkBuildType(androidBuildTypes.getByName("debug"), modelBuildType.getDebug(), configurations);
+ linkBuildType(androidBuildTypes.getByName("release"), modelBuildType.getRelease(), configurations);
+
+ configureTesting(project, dslModel, android);
+
+ configureKotlinSerialization(project, dslModel);
+ configureDesugaring(project, dslModel, android);
+ configureHilt(project, dslModel, android);
+ configureCompose(project, dslModel, android);
+ }
+
+ protected void configureHilt(Project project, AndroidSoftware dslModel, CommonExtension<?, ?, ?, ?, ?, ?> android) {
+ if (dslModel.getHilt().getEnabled().get()) {
+ // Add support for KSP
+ project.getPlugins().apply("com.google.devtools.ksp");
+ project.getDependencies().add("ksp", "com.google.dagger:hilt-android-compiler:2.50");
+
+ // Add support for Hilt
+ project.getPlugins().apply("dagger.hilt.android.plugin");
+ project.getDependencies().add("implementation", "com.google.dagger:hilt-android:2.50");
+ }
+ }
+
+ protected void configureDesugaring(Project project, AndroidSoftware dslModel, CommonExtension<?, ?, ?, ?, ?, ?> android) {
+ if (dslModel.getCoreLibraryDesugaring().getEnabled().get()) {
+ android.compileOptions(compileOptions -> {
+ compileOptions.setCoreLibraryDesugaringEnabled(dslModel.getCoreLibraryDesugaring().getEnabled().get());
+ return null;
+ });
+
+ project.getDependencies().addProvider("coreLibraryDesugaring", dslModel.getCoreLibraryDesugaring().getLibVersion().map(version -> "com.android.tools:desugar_jdk_libs:" + version));
+ }
+ }
+
+ @SuppressWarnings("UnstableApiUsage")
+ protected void configureTesting(Project project, AndroidSoftware dslModel, CommonExtension<?, ?, ?, ?, ?, ?> android) {
+ Testing testing = dslModel.getTesting();
+ AndroidTestDependencies testDependencies = testing.getDependencies();
+ TestOptions testOptions = testing.getTestOptions();
+
+ UnitTestOptions unitTestOptions = android.getTestOptions().getUnitTests();
+ unitTestOptions.setIncludeAndroidResources(testOptions.getIncludeAndroidResources().get());
+ unitTestOptions.setReturnDefaultValues(testOptions.getReturnDefaultValues().get());
+
+ ConfigurationContainer configurations = project.getConfigurations();
+ configurations.getByName("testImplementation").fromDependencyCollector(testDependencies.getImplementation());
+ configurations.getByName("androidTestImplementation").fromDependencyCollector(testDependencies.getAndroidImplementation());
+ }
+
+ @SuppressWarnings("UnstableApiUsage")
+ protected void configureKotlinSerialization(Project project, AndroidSoftware dslModel) {
+ if (dslModel.getKotlinSerialization().getEnabled().get()) {
+ project.getPlugins().apply("org.jetbrains.kotlin.plugin.serialization");
+ project.getConfigurations().getByName("testImplementation").fromDependencyCollector(dslModel.getKotlinSerialization().getDependencies().getImplementation());
+
+ if (dslModel.getKotlinSerialization().getJsonEnabled().get()) {
+ project.getDependencies().addProvider("implementation", dslModel.getKotlinSerialization().getVersion().map(version -> "org.jetbrains.kotlinx:kotlinx-serialization-json:" + version));
+ }
+ }
+ }
+
+ /**
+ * Links build types from the model to the android extension.
+ */
+ protected void linkBuildType(BuildType buildType, AndroidSoftwareBuildType model, ConfigurationContainer configurations) {
+ buildType.setMinifyEnabled(model.getMinify().getEnabled().get());
+ linkBuildTypeDependencies(buildType, model.getDependencies(), configurations);
+ }
+
+ @SuppressWarnings("UnstableApiUsage")
+ protected void linkBuildTypeDependencies(BuildType buildType, AndroidSoftwareDependencies dependencies, ConfigurationContainer configurations) {
+ String name = buildType.getName();
+ configurations.getByName(name + "Implementation").fromDependencyCollector(dependencies.getImplementation());
+ configurations.getByName(name + "CompileOnly").fromDependencyCollector(dependencies.getCompileOnly());
+ configurations.getByName(name + "RuntimeOnly").fromDependencyCollector(dependencies.getRuntimeOnly());
+ }
+
+ protected <T> void ifPresent(Property<T> property, Action<T> action) {
+ if (property.isPresent()) {
+ action.execute(property.get());
+ }
+ }
+}

unified-prototype/unified-plugin/plugin-android/src/main/java/org/gradle/api/experimental/android/AndroidEcosystemPlugin.java

@@ -4,14 +4,11 @@
 import org.gradle.api.experimental.android.application.StandaloneAndroidApplicationPlugin;
 import org.gradle.api.experimental.android.library.StandaloneAndroidLibraryPlugin;
 import org.gradle.api.initialization.Settings;
-import org.gradle.api.internal.SettingsInternal;
 import org.gradle.api.internal.plugins.software.RegistersSoftwareTypes;
-import org.gradle.plugin.software.internal.SoftwareTypeRegistry;
 
 @SuppressWarnings("UnstableApiUsage")
 @RegistersSoftwareTypes({StandaloneAndroidApplicationPlugin.class, StandaloneAndroidLibraryPlugin.class})
-public class AndroidEcosystemPlugin implements Plugin<Settings> {
-
+public abstract class AndroidEcosystemPlugin implements Plugin<Settings> {
  @Override
  public void apply(Settings target) { }
 }

unified-prototype/unified-plugin/plugin-android/src/main/java/org/gradle/api/experimental/android/AndroidSoftware.java

@@ -0,0 +1,114 @@
+package org.gradle.api.experimental.android;
+
+import com.android.build.api.dsl.BaseFlavor;
+import com.android.build.api.dsl.CommonExtension;
+import org.gradle.api.Action;
+import org.gradle.api.experimental.android.extensions.Compose;
+import org.gradle.api.experimental.android.extensions.CoreLibraryDesugaring;
+import org.gradle.api.experimental.android.extensions.Hilt;
+import org.gradle.api.experimental.android.extensions.KotlinSerialization;
+import org.gradle.api.experimental.android.extensions.testing.Testing;
+import org.gradle.api.experimental.android.nia.Feature;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Nested;
+import org.gradle.declarative.dsl.model.annotations.Configuring;
+import org.gradle.declarative.dsl.model.annotations.Restricted;
+
+public interface AndroidSoftware {
+ /**
+ * @see CommonExtension#getCompileSdk()
+ */
+ @Restricted
+ Property<Integer> getCompileSdk();
+
+ /**
+ * @see CommonExtension#getNamespace()
+ */
+ @Restricted
+ Property<String> getNamespace();
+
+ /**
+ * @see BaseFlavor#getMinSdk()
+ */
+ @Restricted
+ Property<Integer> getMinSdk();
+
+ /**
+ * JDK version to use for compilation.
+ */
+ @Restricted
+ Property<Integer> getJdkVersion();
+
+ @Nested
+ AndroidSoftwareBuildTypes getBuildTypes();
+
+ @Nested
+ AndroidSoftwareDependencies getDependencies();
+
+ /**
+ * Controls whether or not to set up Kotlin serialization, applying the plugins
+ * and adding any necessary dependencies.
+ */
+ @Nested
+ KotlinSerialization getKotlinSerialization();
+
+ @Configuring
+ default void kotlinSerialization(Action<? super KotlinSerialization> action) {
+ KotlinSerialization kotlinSerialization = getKotlinSerialization();
+ action.execute(kotlinSerialization);
+ kotlinSerialization.getEnabled().set(true);
+ }
+
+ @Nested
+ Compose getCompose();
+
+ @Configuring
+ default void compose(Action<? super Compose> action) {
+ Compose compose = getCompose();
+ action.execute(compose);
+ compose.getEnabled().set(true);
+ }
+
+ @Nested
+ CoreLibraryDesugaring getCoreLibraryDesugaring();
+
+ @Configuring
+ default void coreLibraryDesugaring(Action<? super CoreLibraryDesugaring> action) {
+ CoreLibraryDesugaring coreLibraryDesugaring = getCoreLibraryDesugaring();
+ action.execute(coreLibraryDesugaring);
+ coreLibraryDesugaring.getEnabled().set(true);
+ }
+
+ @Nested
+ Hilt getHilt();
+
+ @Configuring
+ default void hilt(Action<? super Hilt> action) {
+ Hilt hilt = getHilt();
+ action.execute(hilt);
+ hilt.getEnabled().set(true);
+ }
+
+ @Nested
+ Testing getTesting();
+
+ @Configuring
+ default void testing(Action<? super Testing> action) {
+ action.execute(getTesting());
+ }
+
+ /**
+ * Support for NiA convention projects defining features.
+ * TODO: This is a temporary solution until we have a proper feature model.
+ */
+ @Nested
+ Feature getFeature();
+
+ @Configuring
+ default void feature(Action<? super Feature> action) {
+ Feature feature = getFeature();
+ action.execute(feature);
+ feature.getEnabled().set(true);
+ }
+
+}

unified-prototype/unified-plugin/plugin-android/src/main/java/org/gradle/api/experimental/android/AndroidSoftwareBuildType.java

@@ -0,0 +1,23 @@
+package org.gradle.api.experimental.android;
+
+import org.gradle.api.Action;
+import org.gradle.api.experimental.android.extensions.Minify;
+import org.gradle.api.tasks.Nested;
+import org.gradle.declarative.dsl.model.annotations.Configuring;
+import org.gradle.declarative.dsl.model.annotations.Restricted;
+
+@Restricted
+public interface AndroidSoftwareBuildType {
+ /**
+ * Dependencies for this build type.
+ */
+ AndroidSoftwareDependencies getDependencies();
+
+ @Nested
+ Minify getMinify();
+
+ @Configuring
+ default void minify(Action<? super Minify> action) {
+ action.execute(getMinify());
+ }
+}