Merge branch '218-android-api' into dev

Author: greenrobot-team

.gitlab-ci.yml

@@ -1,10 +1,5 @@
 # https://docs.gitlab.com/ci/yaml/
 
-# Default Docker image (currently only supporting Docker Linux containers)
-# This should match the image used to build the JVM database libraries (so Address Sanitizer library matches).
-# When updating, check if the test-jdk jobs need changing.
-image: objectboxio/buildenv-core:2025-07-03 # With JDK 21
-
 # Assumes these environment variables are configured in GitLab CI/CD Settings:
 # - OBX_READ_PACKAGES_TOKEN
 # - SONATYPE_USER
@@ -36,7 +31,7 @@ variables:
   GITLAB_PUBLISH_ARGS: "-PgitlabPublishTokenName=Job-Token -PgitlabPublishToken=$CI_JOB_TOKEN"
   CENTRAL_PUBLISH_ARGS: "-PsonatypeUsername=$SONATYPE_USER -PsonatypePassword=$SONATYPE_PWD"
   # CI_COMMIT_REF_SLUG is the branch or tag name, but web-safe (only 0-9, a-z)
-  VERSION_ARGS: "-PversionPostFix=$CI_COMMIT_REF_SLUG"
+  VERSION_ARGS: "-PversionSuffix=$CI_COMMIT_REF_SLUG"
 
 # Using multiple test stages to avoid running some things in parallel (see job notes).
 stages:
@@ -65,28 +60,47 @@ workflow:
     # In all other cases, create a pipeline
     - when: always
 
-test:
-  stage: test
+.docker_linux_x64_android: &docker_linux_x64_android
   tags:
     - docker
     - linux
     - x64
+  image: objectboxio/buildenv-android:2024-12-09 # With JDK 21, Android build-tools;35.0.0 and platforms;android-35 pre-installed
   variables:
     # Image defaults to POSIX (ASCII), set a compatible locale so UTF-8 tests that interact with the file system work.
     # Check with 'locale -a' for available locales.
     LC_ALL: "C.UTF-8"
+
+.test_base:
   before_script:
     # Print Gradle and JVM version info
     - ./gradlew -version
     # Remove any previous JVM (Hotspot) crash log.
     # "|| true" for an OK exit code if no file is found
     - rm **/hs_err_pid*.log || true
+  # By default, don't compile and test the Android APIs (only do in test job), there is currently no benefit to test
+  # them using multiple platforms or JDKs.
+  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build -PexcludeAndroid=true
+  artifacts:
+    when: always
+    paths:
+      - "**/hs_err_pid*.log" # Only on JVM (Hotspot) crash
+    reports:
+      junit: "**/build/test-results/**/TEST-*.xml"
+
+test:
+  <<: *docker_linux_x64_android
+  extends: .test_base
+  stage: test
+  # Overwrite script key to run through ASAN script, compile and test Android APIs and test build of Web API docs.
+  # Note: Address sanitizer is only available on Linux runners (see script).
   script:
     # build to assemble, run tests and spotbugs
     # javadocForWeb to catch API docs errors before releasing
     # Temporarily disable testing with Address Sanitizer until buildenv images are modernized, see #273
     # - ./scripts/test-with-asan.sh $GITLAB_REPO_ARGS $VERSION_ARGS clean build javadocForWeb
     - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build javadocForWeb
+  # Overwrite artifacts key to archive spotbugs reports
   artifacts:
     when: always
     paths:
@@ -95,88 +109,59 @@ test:
     reports:
       junit: "**/build/test-results/**/TEST-*.xml"
 
-.test-template:
-  before_script:
-    # Print Gradle and JVM version info
-    - ./gradlew -version
-    # Remove any previous JVM (Hotspot) crash log.
-    # "|| true" for an OK exit code if no file is found
-    - rm **/hs_err_pid*.log || true
-  artifacts:
-    when: always
-    paths:
-      - "**/hs_err_pid*.log" # Only on JVM (Hotspot) crash.
-    reports:
-      junit: "**/build/test-results/**/TEST-*.xml"
-
-test-windows:
-  extends: .test-template
-  needs: ["test"]
-  tags:
-    - windows-jdk
-    - x64
-  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build
-
-test-macos:
-  extends: .test-template
-  needs: ["test"]
-  tags:
-    - jdk
-    - mac
-  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build
-
-# Address sanitizer is only available on Linux runners (see script).
-.test-asan-template:
-  extends: .test-template
-  tags:
-    - docker
-    - linux
-    - x64
-  variables:
-    # Image defaults to POSIX (ASCII), set a compatible locale so UTF-8 tests that interact with the file system work.
-    # Check with 'locale -a' for available locales.
-    LC_ALL: "C.UTF-8"
+.test_jdks:
+  <<: *docker_linux_x64_android
+  extends: .test_base
+  # Overwrite script key to run through ASAN script and to run test task directly to avoid
+  # running SpotBugs (build runs check runs SpotBugs tasks).
+  # Note: Address sanitizer is only available on Linux runners (see script).
   script:
-    # Note: do not run check task as it includes SpotBugs.
     # Temporarily disable testing with Address Sanitizer until buildenv images are modernized, see #273
     # - ./scripts/test-with-asan.sh $GITLAB_REPO_ARGS $VERSION_ARGS clean :tests:objectbox-java-test:test
     - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean :tests:objectbox-java-test:test
 
 # Test oldest supported and a recent JDK.
 # Note: can not run these in parallel using a matrix configuration as Gradle would step over itself.
 test-jdk-8:
-  extends: .test-asan-template
+  extends: .test_jdks
   needs: ["test"]
   variables:
     TEST_JDK: 8
 
 # JDK 21 is the default of the current build image, so test the latest LTS JDK 25
 test-jdk-25:
-  extends: .test-asan-template
+  extends: .test_jdks
   needs: ["test-jdk-8"]
   variables:
     TEST_JDK: 25
 
-test-jdk-x86:
-  extends: .test-template
-  needs: ["test-windows"]
+test-macos:
+  extends: .test_base
+  tags:
+    - jdk
+    - mac
+
+test-windows:
+  extends: .test_base
   tags:
     - windows-jdk
     - x64
+
+test-windows-jdk-x86:
+  extends: .test_base
+  needs: ["test-windows"]
+  tags:
+    - windows-jdk-x86
   variables:
     # TEST_WITH_JAVA_X86 makes objectbox-java-test use 32-bit java executable and therefore
     # 32-bit ObjectBox to run tests (see build.gradle file).
     # Note: assumes JAVA_HOME_X86 is set to 32-bit JDK path.
     TEST_WITH_JAVA_X86: "true"
-  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build
 
 # Publish Maven artifacts to internal Maven repo
 publish-maven-internal:
+  <<: *docker_linux_x64_android
   stage: publish-maven-internal
-  tags:
-    - docker
-    - linux
-    - x64
   rules:
     # Not when using release versions and not publishing a release to avoid duplicate artifacts
     # (GitLab would allow to upload duplicates for a release version)
@@ -191,36 +176,30 @@ publish-maven-internal:
     # Otherwise, only if no previous stages failed
     - when: on_success
   script:
-    - ./gradlew $GITLAB_REPO_ARGS $GITLAB_PUBLISH_ARGS $VERSION_ARGS publishMavenJavaPublicationToGitLabRepository
+    - ./gradlew $GITLAB_REPO_ARGS $GITLAB_PUBLISH_ARGS $VERSION_ARGS publishAllPublicationsToGitLabRepository
 
 # Publish Maven artifacts to public Maven Central repo
 publish-maven-central:
+  <<: *docker_linux_x64_android
   stage: publish-maven-central
-  tags:
-    - docker
-    - linux
-    - x64
   rules:
     # Only if publishing a release, only if no previous stages failed
     - if: $OBX_PUBLISH_RELEASE == "true"
       when: on_success
   before_script:
-    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java library:* job $CI_JOB_NAME from branch $CI_COMMIT_BRANCH ($CI_COMMIT_SHORT_SHA)..."
+    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java libraries to Maven Central:* job $CI_JOB_NAME from branch $CI_COMMIT_BRANCH ($CI_COMMIT_SHORT_SHA)..."
   script:
-    # Note: supply internal repo as tests use native dependencies that might not be published, yet.
-    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS $CENTRAL_PUBLISH_ARGS publishMavenJavaPublicationToSonatypeRepository closeAndReleaseSonatypeStagingRepository
+    # Note: supply internal repo as tests use native dependencies that might not be available publicly, yet.
+    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS $CENTRAL_PUBLISH_ARGS publishAllPublicationsToSonatypeRepository closeAndReleaseSonatypeStagingRepository
   after_script:
     # Also runs on failure, so show CI_JOB_STATUS.
-    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java library:* *$CI_JOB_STATUS* for $CI_JOB_NAME"
+    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java libraries to Maven Central:* *$CI_JOB_STATUS* for $CI_JOB_NAME"
     - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "Check https://repo1.maven.org/maven2/io/objectbox/ in a few minutes."
 
 # Create Java API docs archive
 package-api-docs:
+  <<: *docker_linux_x64_android
   stage: package-api-docs
-  tags:
-    - docker
-    - linux
-    - x64
   rules:
     # Only if publishing a release, only if no previous stages failed
     - if: $OBX_PUBLISH_RELEASE == "true"

CHANGELOG.md

@@ -6,6 +6,8 @@ For more insights into what changed in the database libraries, [check the Object
 
 ## Next release
 
+- Update Android and JVM libraries to database version `5.3.1-next-2026-04-24`
+
 ## 5.4.1 - 2026-03-26
 
 - Update Android and JVM libraries to database version `5.3.1-2026-03-26`

Jenkinsfile

@@ -6,7 +6,7 @@ String buildsToKeep = '500'
 
 String gradleArgs = '--stacktrace'
 boolean isPublish = BRANCH_NAME == 'publish'
-String versionPostfix = isPublish ? '' : BRANCH_NAME // Build script detects empty string as not set.
+String versionSuffix = isPublish ? '' : BRANCH_NAME // Build script detects empty string as not set.
 
 // Note: using single quotes to avoid Groovy String interpolation leaking secrets.
 def signingArgs = '-PsigningKeyFile=$SIGNING_FILE -PsigningKeyId=$SIGNING_ID -PsigningPassword=$SIGNING_PWD'
@@ -107,7 +107,7 @@ pipeline {
 
         stage('upload-to-internal') {
             steps {
-                sh "./gradlew $gradleArgs $signingArgs $gitlabRepoArgs -PversionPostFix=$versionPostfix publishMavenJavaPublicationToGitLabRepository"
+                sh "./gradlew $gradleArgs $signingArgs $gitlabRepoArgs -PversionSuffix=$versionSuffix publishMavenJavaPublicationToGitLabRepository"
             }
         }
 

build-logic/README.md

@@ -0,0 +1,21 @@
+# Build logic project
+
+This project provides common build logic and is included as a composite build in the root settings file (as it provides
+a plugin, in the `pluginManagement` block instead of before the usual include statements):
+
+```kotlin
+pluginManagement {
+    includeBuild("build-logic")
+}
+```
+
+## Convention Plugins
+
+- [objectbox.publishing-conventions](src/main/kotlin/objectbox.publishing-conventions.gradle.kts): adds GitLab repo,
+  configures common Maven POM values, configures signing of artifacts
+
+## Related Gradle documentation
+
+- https://docs.gradle.org/current/userguide/composite_builds.html#included_plugin_builds
+- https://docs.gradle.org/current/userguide/best_practices_structuring_builds.html#use_convention_plugins
+- https://github.com/gradle/gradle/tree/master/platforms/documentation/docs/src/snippets/best-practices/useConventionPlugins-do

buildSrc/build.gradle.kts build-logic/build.gradle.ktsbuildSrc/build.gradle.kts renamed to build-logic/build.gradle.kts

@@ -0,0 +1 @@
+rootProject.name = "build-logic"

build-logic/settings.gradle.kts

@@ -1,4 +1,4 @@
-// This script requires some Gradle project properties to be set
+// This convention plugin expects some Gradle project properties to be set
 // (to set as environment variable prefix with ORG_GRADLE_PROJECT_):
 // https://docs.gradle.org/current/userguide/build_environment.html#sec:project_properties
 //
@@ -12,39 +12,49 @@
 // - signingKeyId
 // - signingPassword
 
+// Gradle properties
+val gitlabUrl = providers.gradleProperty("gitlabUrl")
+val gitlabPublishToken = providers.gradleProperty("gitlabPublishToken")
+val gitlabPublishTokenName = providers.gradleProperty("gitlabPublishTokenName")
+// The following properties are used for signing in CI using a key file
+val signingKeyFile = providers.gradleProperty("signingKeyFile")
+val signingKeyId = providers.gradleProperty("signingKeyId")
+val signingPassword = providers.gradleProperty("signingPassword")
+
 plugins {
     id("maven-publish")
     id("signing")
 }
 
 publishing {
     repositories {
+        // If the applied to project has the required properties, configures the "GitLab" repository for publishing
+        // (Note: always adding it, even without credentials, so it's possible to see the tasks created for it.)
         maven {
             name = "GitLab"
-            if (project.hasProperty("gitlabUrl") && project.hasProperty("gitlabPublishToken")) {
+            if (gitlabUrl.isPresent && gitlabPublishToken.isPresent) {
                 // "https://gitlab.example.com/api/v4/projects/<PROJECT_ID>/packages/maven"
-                val gitlabUrl = project.property("gitlabUrl")
-                url = uri("$gitlabUrl/api/v4/projects/14/packages/maven")
+                url = uri("${gitlabUrl.get()}/api/v4/projects/14/packages/maven")
                 credentials(HttpHeaderCredentials::class) {
-                    name = project.findProperty("gitlabPublishTokenName")?.toString() ?: "Private-Token"
-                    value = project.property("gitlabPublishToken").toString()
+                    name = gitlabPublishTokenName.orNull ?: "Private-Token"
+                    value = gitlabPublishToken.get()
                 }
                 authentication {
                     create<HttpHeaderAuthentication>("header")
                 }
                 println("Publishing: configured GitLab repository $url")
             } else {
-                println("Publishing: GitLab repository not configured")
+                println("Publishing: GitLab repository NOT configured, see publishing-conventions plugin for required project properties")
             }
         }
         // Note: Sonatype repo created by publish-plugin, see root build.gradle.kts.
     }
 
     publications {
-        create<MavenPublication>("mavenJava") {
+        // Common settings for all Maven publications
+        withType<MavenPublication> {
             // Note: Projects set additional specific properties.
             pom {
-                packaging = "jar"
                 url.set("https://objectbox.io")
                 licenses {
                     license {
@@ -78,24 +88,15 @@ publishing {
 }
 
 signing {
-    if (hasSigningProperties()) {
+    if (signingKeyFile.isPresent && signingKeyId.isPresent && signingPassword.isPresent) {
         // Sign using an ASCII-armored key read from a file
         // https://docs.gradle.org/current/userguide/signing_plugin.html#using_in_memory_ascii_armored_openpgp_subkeys
-        val signingKey = File(project.property("signingKeyFile").toString()).readText()
-        useInMemoryPgpKeys(
-            project.property("signingKeyId").toString(),
-            signingKey,
-            project.property("signingPassword").toString()
-        )
-        sign(publishing.publications["mavenJava"])
-        println("Publishing: configured signing with key file")
+        val keyFilePath = signingKeyFile.get()
+        val signingKey = File(keyFilePath).readText()
+        useInMemoryPgpKeys(signingKeyId.get(), signingKey, signingPassword.get())
+        println("Publishing: signing configured with key file $keyFilePath")
     } else {
-        println("Publishing: signing not configured")
+        isRequired = false // Don't run sign tasks
+        println("Publishing: signing NOT configured, see publishing-conventions plugin for required project properties")
     }
 }
-
-fun hasSigningProperties(): Boolean {
-    return (project.hasProperty("signingKeyId")
-            && project.hasProperty("signingKeyFile")
-            && project.hasProperty("signingPassword"))
-}