Merge branch 'publish'

Author: greenrobot-team

CHANGELOG.md

@@ -4,6 +4,18 @@ Notable changes to the ObjectBox Java library.
 
 For more insights into what changed in the database libraries, [check the ObjectBox C changelog](https://github.com/objectbox/objectbox-c/blob/main/CHANGELOG.md).
 
+## 5.4.0 - 2026-03-24
+
+- Update Android and JVM libraries to database version `5.3.0-2026-03-23`
+- Admin: Status tab "Count and Sizes" and "System and Info" improved
+
+### Sync
+
+- Conflict resolution via the new annotations `@SyncClock` and `@SyncPrecedence` (allows last win with custom conflict
+  resolution)
+- Fix bad Sync client state after multiple full sync messages were interrupted
+- Fix adding indexes to Sync types
+
 ## 5.3.0 - 2026-03-10
 
 - Gradle plugin: to apply the plugin, it is no longer necessary to add a manual mapping of the plugin ID in your

README.md

@@ -151,7 +151,7 @@ agp = "AGP_VERSION"
 kotlin = "KOTLIN_VERSION"
 
 # Define a variable for the version of the ObjectBox plugin
-objectbox = "5.3.0"
+objectbox = "5.4.0"
 
 [plugins]
 # For an Android project, using Android Gradle Plugin 9.0 or newer
@@ -251,7 +251,7 @@ Your project can now use ObjectBox, continue by [defining entity classes](https:
 
 plugins {
     // Add the ObjectBox plugin
-    id("io.objectbox") version "5.3.0" apply false
+    id("io.objectbox") version "5.4.0" apply false
 }
 ```
 
@@ -283,7 +283,7 @@ dependencyResolutionManagement {
 
 buildscript {
     // Define a variable for the ObjectBox plugin version
-    val objectboxVersion by extra("5.3.0")
+    val objectboxVersion by extra("5.4.0")
 
     repositories {
         // Add Maven Central to the plugin repositories     
@@ -313,7 +313,7 @@ allprojects {
 
 buildscript {
     // Define a variable for the ObjectBox plugin version
-    ext.objectboxVersion = "5.3.0"
+    ext.objectboxVersion = "5.4.0"
   
     repositories {        
         // Add Maven Central to the plugin repositories

build.gradle.kts

@@ -20,7 +20,7 @@ plugins {
 buildscript {
     // Version of Maven artifacts
     // Should only be changed as part of the release process, see the release checklist in the objectbox repo
-    val versionNumber = "5.3.0"
+    val versionNumber = "5.4.0"
 
     // Release mode should only be enabled when manually triggering a CI pipeline,
     // see the release checklist in the objectbox repo.

objectbox-java-api/src/main/java/io/objectbox/annotation/SyncClock.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * 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 io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a {@code long} (64-bit integer) field of a {@link Sync}-enabled {@link Entity} class as the sync clock, a
+ * "hybrid logical clock" to resolve Sync conflicts.
+ * <p>
+ * These clock values allow "last write wins" conflict resolution.
+ * <p>
+ * There can be only one sync clock per sync entity type; which is also recommended for basic conflict resolution.
+ * <p>
+ * For new objects, initialize the property value to {@code 0} to reserve "a slot" in the object data. ObjectBox Sync
+ * will update this property automatically on put operations.
+ * <p>
+ * As a hybrid clock, it combines a wall clock with a logical counter to compensate for some clock skew effects.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface SyncClock {
+}

objectbox-java-api/src/main/java/io/objectbox/annotation/SyncPrecedence.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * 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 io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a {@code long} (64-bit integer) field of a {@link Sync}-enabled {@link Entity} class as the "sync precedence"
+ * to customize Sync conflict resolution.
+ * <p>
+ * Developer-assigned precedence values are then used to resolve conflicts via "higher precedence wins". Defining and
+ * assigning precedence values are completely in the hands of the developer (the ObjectBox user).
+ * <p>
+ * There can be only one sync precedence per sync entity type.
+ * <p>
+ * Typically, it is combined with a {@link SyncClock}, with the latter being the tie-breaker for equal precedence
+ * values.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface SyncPrecedence {
+}

objectbox-java/src/main/java/io/objectbox/BoxStore.java

@@ -82,7 +82,7 @@ public class BoxStore implements Closeable {
      * ReLinker uses this as a suffix for the extracted shared library file. If different, it will update it. Should be
      * unique to avoid conflicts.
      */
-    public static final String JNI_VERSION = "5.2.0-2026-03-10";
+    public static final String JNI_VERSION = "5.3.0-2026-03-23";
 
     /**
      * The ObjectBox database version this Java library is known to work with.
@@ -92,7 +92,7 @@ public class BoxStore implements Closeable {
      * This is used (currently only in tests) to make sure a database library has a compatible JNI API by checking the
      * version number matches exactly and the date is the same or newer.
      */
-    private static final String VERSION = "5.2.0-2026-03-10";
+    private static final String VERSION = "5.3.0-2026-03-23";
 
     private static final String OBJECTBOX_PACKAGE_NAME = "objectbox";
     private static BoxStore defaultStore;

objectbox-java/src/main/java/io/objectbox/config/FlatStoreOptions.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 ObjectBox Ltd.
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -180,6 +180,11 @@ public final class FlatStoreOptions extends Table {
    * Flags to change the default behavior for restoring backups, e.g. what should happen to existing data.
    */
   public long backupRestoreFlags() { int o = __offset(38); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Options for write-ahead logging (WAL)
+   */
+  public WalOptions walOptions() { return walOptions(new WalOptions()); }
+  public WalOptions walOptions(WalOptions obj) { int o = __offset(40); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
 
   public static int createFlatStoreOptions(FlatBufferBuilder builder,
       int directoryPathOffset,
@@ -199,11 +204,13 @@ public static int createFlatStoreOptions(FlatBufferBuilder builder,
       long maxDataSizeInKbyte,
       int validateOnOpenKv,
       int backupFileOffset,
-      long backupRestoreFlags) {
-    builder.startTable(18);
+      long backupRestoreFlags,
+      int walOptionsOffset) {
+    builder.startTable(19);
     FlatStoreOptions.addMaxDataSizeInKbyte(builder, maxDataSizeInKbyte);
     FlatStoreOptions.addValidateOnOpenPageLimit(builder, validateOnOpenPageLimit);
     FlatStoreOptions.addMaxDbSizeInKbyte(builder, maxDbSizeInKbyte);
+    FlatStoreOptions.addWalOptions(builder, walOptionsOffset);
     FlatStoreOptions.addBackupRestoreFlags(builder, backupRestoreFlags);
     FlatStoreOptions.addBackupFile(builder, backupFileOffset);
     FlatStoreOptions.addDebugFlags(builder, debugFlags);
@@ -222,7 +229,7 @@ public static int createFlatStoreOptions(FlatBufferBuilder builder,
     return FlatStoreOptions.endFlatStoreOptions(builder);
   }
 
-  public static void startFlatStoreOptions(FlatBufferBuilder builder) { builder.startTable(18); }
+  public static void startFlatStoreOptions(FlatBufferBuilder builder) { builder.startTable(19); }
   public static void addDirectoryPath(FlatBufferBuilder builder, int directoryPathOffset) { builder.addOffset(0, directoryPathOffset, 0); }
   public static void addModelBytes(FlatBufferBuilder builder, int modelBytesOffset) { builder.addOffset(1, modelBytesOffset, 0); }
   public static int createModelBytesVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
@@ -244,6 +251,7 @@ public static int createFlatStoreOptions(FlatBufferBuilder builder,
   public static void addValidateOnOpenKv(FlatBufferBuilder builder, int validateOnOpenKv) { builder.addShort(15, (short) validateOnOpenKv, (short) 0); }
   public static void addBackupFile(FlatBufferBuilder builder, int backupFileOffset) { builder.addOffset(16, backupFileOffset, 0); }
   public static void addBackupRestoreFlags(FlatBufferBuilder builder, long backupRestoreFlags) { builder.addInt(17, (int) backupRestoreFlags, (int) 0L); }
+  public static void addWalOptions(FlatBufferBuilder builder, int walOptionsOffset) { builder.addOffset(18, walOptionsOffset, 0); }
   public static int endFlatStoreOptions(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;

objectbox-java/src/main/java/io/objectbox/config/WalFlags.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * 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.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+/**
+ * WAL flags control how the store handles WAL files.
+ */
+@SuppressWarnings("unused")
+public final class WalFlags {
+  private WalFlags() { }
+  /**
+   * Enable WAL
+   */
+  public static final int EnableWal = 1;
+  /**
+   * Does not wait for the disk to acknowledge
+   */
+  public static final int NoFileSync = 2;
+}
+

objectbox-java/src/main/java/io/objectbox/config/WalOptions.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * 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.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.Table;
+
+/**
+ * Options to enable and configure WAL.
+ */
+@SuppressWarnings("unused")
+public final class WalOptions extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static WalOptions getRootAsWalOptions(ByteBuffer _bb) { return getRootAsWalOptions(_bb, new WalOptions()); }
+  public static WalOptions getRootAsWalOptions(ByteBuffer _bb, WalOptions obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public WalOptions __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /**
+   * Flags to enable and change default WAL behavior, e.g. no sync to disk option.
+   */
+  public long walFlags() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * The WAL file gets consolidated when it reached this size limit when opening the database.
+   * This setting is meant for applications that prefer to consolidate on startup,
+   * which may avoid consolidations on commits while the application is running.
+   * The default is 4096 (4 MB).
+   */
+  public long maxWalFileSizeOnOpenInKbyte() { int o = __offset(6); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * The WAL file gets consolidated when it reaches this size limit after a commit.
+   * As consolidation takes some time, it is a trade-off between accumulating enough data
+   * and the time the consolidation takes (longer with more data).
+   * The default is 16384 (16 MB).
+   */
+  public long maxWalFileSizeInKbyte() { int o = __offset(8); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+
+  public static int createWalOptions(FlatBufferBuilder builder,
+      long walFlags,
+      long maxWalFileSizeOnOpenInKbyte,
+      long maxWalFileSizeInKbyte) {
+    builder.startTable(3);
+    WalOptions.addMaxWalFileSizeInKbyte(builder, maxWalFileSizeInKbyte);
+    WalOptions.addMaxWalFileSizeOnOpenInKbyte(builder, maxWalFileSizeOnOpenInKbyte);
+    WalOptions.addWalFlags(builder, walFlags);
+    return WalOptions.endWalOptions(builder);
+  }
+
+  public static void startWalOptions(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void addWalFlags(FlatBufferBuilder builder, long walFlags) { builder.addInt(0, (int) walFlags, (int) 0L); }
+  public static void addMaxWalFileSizeOnOpenInKbyte(FlatBufferBuilder builder, long maxWalFileSizeOnOpenInKbyte) { builder.addLong(1, maxWalFileSizeOnOpenInKbyte, 0L); }
+  public static void addMaxWalFileSizeInKbyte(FlatBufferBuilder builder, long maxWalFileSizeInKbyte) { builder.addLong(2, maxWalFileSizeInKbyte, 0L); }
+  public static int endWalOptions(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public WalOptions get(int j) { return get(new WalOptions(), j); }
+    public WalOptions get(WalOptions obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+

objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 ObjectBox Ltd.
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -103,5 +103,29 @@ private PropertyFlags() { }
    * However, the deletion process can be triggered by an API call.
    */
   public static final int EXPIRATION_TIME = 65536;
+  /**
+   * Marks a Long (64-bit integer) property as a the sync clock, a "hybrid logical clock" to resolve Sync conflicts.
+   * These clock values allow "last write wins" conflict resolution.
+   * There can be only one sync clock per sync entity type; which is also recommended for basic conflict resolution.
+   * For new objects, initialize a property value to 0 to reserve "a slot" in the object data.
+   * ObjectBox Sync will update this property automatically on put operations.
+   * As a hybrid clock, it combines a wall clock with a logical counter to compensate for some clock skew effects.
+   */
+  public static final int SYNC_CLOCK = 131072;
+  /**
+   * Marks a Long (64-bit integer) property as a the "sync precedence" to customize Sync conflict resolution.
+   * Developer-assigned precedence values are then used to resolve conflicts via "higher precedence wins".
+   * Defining and assigning precedence values are completely in the hands of the developer (the ObjectBox user).
+   * There can be only one sync precedence per sync entity type.
+   * Typically, it is combined with a sync clock, with the latter being the tie-breaker for equal precedence values.
+   * This can be used to model some business logic use cases, for example:
+   *   - Setting an object a special state, e.g. a final/closed state, which may not be overwritten by a lesser state
+   *   - Multiple workflow states that occur linearly (i.e. using an increasing precedence value)
+   *   - Role based, e.g. only admins set or increment the precedence..
+   *   - “Checkpoint timestamps:” e.g. when some changes are “checked” as in approved/applied,
+   *     the precedence is updated to the current timestamp.
+   *     “Non-checked” or previously checkpointed changes are disregarded.
+   */
+  public static final int SYNC_PRECEDENCE = 262144;
 }