Use convention plugins instead of script plugins

.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: Build the sample project and upload artifacts if possible
+name: Build and test projects
 
 on:
   push:
@@ -12,6 +12,25 @@ on:
 
 
 jobs:
+  sdk-build:
+    runs-on: ubuntu-latest
+    if: >
+      github.event_name != 'workflow_dispatch'
+    env:
+      GRADLE_OPTS: -Dorg.gradle.jvmargs="-Xmx4g -XX:MaxMetaspaceSize=2g -Dkotlin.daemon.jvm.options=-Xmx1536m"
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        with:
+          java-version: '17.x'
+          java-package: jdk
+          distribution: 'temurin'
+          cache: 'gradle'
+      - name: Check sdk publications
+        run: ./scripts/verify-publications.bash sdk
+      - name: Check sdk-mock publications
+        run: ./scripts/verify-publications.bash sdkMock
+
   build-and-upload:
     runs-on: ubuntu-latest
     if: >
@@ -46,8 +65,6 @@ jobs:
               --url 'https://deploygate.com/api/users/${{ secrets.SHARED_DEPLOYGATE_APP_OWNER_NAME_FOR_PUBLIC_REPO }}/apps' | \
               jq -r '"\(.results.package_name) \(.results.distribution.url)"'
           done < <(find ./sample/build/outputs/bundle -name "*.aab")
-      - name: Check javadocs
-        run: ./gradlew sdk:generateJavadocForReleasePublication sdkMock:generateJavadocForReleasePublication
 
   distribute-stable:
     runs-on: ubuntu-latest

build.gradle

@@ -1,36 +1,10 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
-ext {
-    // sdk/java/com/deploygate/sdk/HostAppTest.java needs to be changed for a new release
-    releaseVersion = '4.7.1'
-}
-
-buildscript {
-    repositories {
-        mavenCentral()
-        google()
-        gradlePluginPortal()
-    }
-    dependencies {
-        classpath 'com.android.tools.build:gradle:7.4.2'
-        classpath 'com.project.starter:easylauncher:5.0.1'
-    }
-}
 
-allprojects {
-    repositories {
-        mavenCentral()
-        google()
-    }
+plugins {
+    id("com.deploygate.plugins.sdk") apply false
+    id("com.deploygate.plugins.sample-app") apply false
 }
 
 task clean(type: Delete) {
     delete rootProject.buildDir
 }
-
-task verifyReleaseVersion() {
-    doLast {
-        if (project.ext.releaseVersion != System.getenv("RELEASE_VERSION")) {
-            throw new GradleException("${project.ext.releaseVersion} does not equal to ${System.getenv("RELEASE_VERSION")}")
-        }
-    }
-}

gradle.properties

@@ -1 +1,2 @@
-android.useAndroidX=true
+android.useAndroidX=true
+android.disableAutomaticComponentCreation=true

plugins/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    `kotlin-dsl` apply false
+}
+
+tasks.register("clean", Delete::class) {
+    delete(rootProject.buildDir)
+}

plugins/library/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.22")
+    implementation("com.android.tools.build:gradle:7.4.2")
+}
+
+gradlePlugin {
+    plugins {
+        create("sdk") {
+            id = "com.deploygate.plugins.sdk"
+            implementationClass = "com.deploygate.plugins.SdkPlugin"
+        }
+    }
+}

plugins/library/src/main/java/com/deploygate/plugins/MavenPublishPlugin.kt

@@ -0,0 +1,162 @@
+package com.deploygate.plugins
+
+import com.deploygate.plugins.ext.internalApiLibraryExtension
+import com.deploygate.plugins.ext.publishingExtension
+import com.deploygate.plugins.ext.sdkExtension
+import com.deploygate.plugins.ext.signingExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.repositories.PasswordCredentials
+import org.gradle.api.publish.PublicationContainer
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.tasks.Exec
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.create
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.register
+import org.gradle.plugins.signing.SigningExtension
+import java.util.Locale
+
+class MavenPublishPlugin : Plugin<Project> {
+    companion object {
+        private val RELEASE_VERSION_REGEX = "^\\d+\\.\\d+\\.\\d+\$".toRegex()
+    }
+
+    override fun apply(target: Project) {
+        target.apply(plugin = "maven-publish")
+        target.apply(plugin = "signing")
+
+        val artifactVersion = target.version as String
+
+        val repositoryUsername = target.findProperty("NEXUS_USERNAME") as? String
+        val repositoryPassword = target.findProperty("NEXUS_PASSWORD") as? String
+        val signingKey = target.findProperty("signingKey") as? String
+        val signingPassword = target.findProperty("signingPassword") as? String
+
+        val isRelease = artifactVersion.matches(RELEASE_VERSION_REGEX)
+
+        target.internalApiLibraryExtension.libraryVariants.configureEach {
+            val variant = this
+
+            target.tasks.register<Exec>("verifyBytecodeVersion${variant.name.capitalize(Locale.ROOT)}")
+                .configure {
+                    dependsOn(variant.assembleProvider)
+
+                    commandLine(
+                        target.rootProject.file("scripts/verify-bytecode-version"),
+                        "--aar",
+                        variant.packageLibraryProvider.flatMap { it.archiveFile }.get(),
+                        "--java",
+                        SdkPlugin.JAVA_VERSION.toString()
+                    )
+                }
+        }
+
+        target.publishingExtension.configurePublishingExtension(
+            target = target,
+            artifactVersion = artifactVersion,
+            isRelease = isRelease,
+            repositoryUsername = repositoryUsername,
+            repositoryPassword = repositoryPassword,
+        )
+        target.signingExtension.configureSigningExtension(
+            isSigningRequired = isRelease,
+            signingKey = signingKey,
+            signingPassword = signingPassword,
+            publications = target.extensions.getByType<PublishingExtension>().publications,
+        )
+
+        target.gradle.taskGraph.whenReady {
+            with(target.signingExtension) {
+                isRequired = isRequired && hasTask("publishReleasePublicationToMavenRepository")
+            }
+        }
+    }
+
+    private fun PublishingExtension.configurePublishingExtension(
+        target: Project,
+        artifactVersion: String,
+        isRelease: Boolean,
+        repositoryUsername: String?,
+        repositoryPassword: String?,
+    ) {
+        repositories {
+            maven {
+                setUrl(
+                    if (isRelease) {
+                        "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
+                    } else {
+                        "https://oss.sonatype.org/content/repositories/snapshots/"
+                    }
+                )
+
+                credentials(PasswordCredentials::class.java) {
+                    username = repositoryUsername
+                    password = repositoryPassword
+                }
+            }
+        }
+
+
+        publications {
+            create<MavenPublication>("release") {
+                // This block would be evaluated before components.getByName("release") was created
+
+                groupId = "com.deploygate"
+                version = artifactVersion
+
+                pom {
+                    name.set(target.sdkExtension.displayName)
+                    description.set(target.sdkExtension.description)
+                    url.set("https://github.com/DeployGate/deploygate-android-sdk")
+
+                    licenses {
+                        license {
+                            name.set("The Apache Software License, Version 2.0")
+                            url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
+                            distribution.set("repo")
+                        }
+                    }
+
+                    developers {
+                        developer {
+                            id.set("deploygate")
+                            name.set("DeployGate")
+                        }
+                    }
+
+                    scm {
+                        url.set("https://github.com/DeployGate/deploygate-android-sdk")
+                    }
+                }
+            }
+        }
+
+        target.afterEvaluate {
+            publications {
+                // Configure some values after AGP has been configured
+                named<MavenPublication>("release") {
+                    from(components.getByName("release"))
+                    artifactId = sdkExtension.artifactId.get()
+                }
+            }
+        }
+    }
+
+
+    private fun SigningExtension.configureSigningExtension(
+        isSigningRequired: Boolean,
+        signingKey: String?,
+        signingPassword: String?,
+        publications: PublicationContainer,
+    ) {
+        isRequired = isSigningRequired
+        useInMemoryPgpKeys(signingKey, signingPassword)
+
+        publications.configureEach {
+            sign(this)
+        }
+    }
+}