InternalAccess: sanction their use, annotate all methods as internal

Author: greenrobot-team

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

@@ -22,14 +22,12 @@
 import io.objectbox.sync.SyncClient;
 
 /**
- * This is a workaround to access internal APIs, notably for tests.
- * <p>
- * To avoid this, future APIs should be exposed via interfaces with an internal implementation that can be used by
- * tests.
+ * Exposes internal APIs to tests and code in other packages.
  */
 @Internal
 public class InternalAccess {
 
+    @Internal
     public static Transaction getActiveTx(BoxStore boxStore) {
         Transaction tx = boxStore.activeTx.get();
         if (tx == null) {
@@ -39,31 +37,43 @@ public static Transaction getActiveTx(BoxStore boxStore) {
         return tx;
     }
 
+    @Internal
     public static long getHandle(Transaction tx) {
         return tx.internalHandle();
     }
 
+    @Internal
     public static void setSyncClient(BoxStore boxStore, @Nullable SyncClient syncClient) {
         boxStore.setSyncClient(syncClient);
     }
 
+    @Internal
     public static <T> Cursor<T> getWriter(Box<T> box) {
         return box.getWriter();
     }
 
+    @Internal
     public static <T> Cursor<T> getActiveTxCursor(Box<T> box) {
         return box.getActiveTxCursor();
     }
 
+    @Internal
     public static <T> long getActiveTxCursorHandle(Box<T> box) {
         return box.getActiveTxCursor().internalHandle();
     }
 
+    @Internal
     public static <T> void commitWriter(Box<T> box, Cursor<T> writer) {
         box.commitWriter(writer);
     }
 
-    /** Makes creation more expensive, but lets Finalizers show the creation stack for dangling resources. */
+    /**
+     * Makes creation more expensive, but lets Finalizers show the creation stack for dangling resources.
+     * <p>
+     * Currently used by integration tests.
+     */
+    @SuppressWarnings("unused")
+    @Internal
     public static void enableCreationStackTracking() {
         Transaction.TRACK_CREATION_STACK = true;
         Cursor.TRACK_CREATION_STACK = true;

objectbox-java/src/main/java/io/objectbox/query/InternalQueryAccess.java renamed to objectbox-java/src/main/java/io/objectbox/query/InternalAccess.java

@@ -19,17 +19,12 @@
 import io.objectbox.annotation.apihint.Internal;
 
 /**
- * This is a workaround to access internal APIs for tests.
- * <p>
- * To avoid this, future APIs should be exposed via interfaces with an internal implementation that can be used by
- * tests.
+ * Exposes internal APIs to tests and code in other packages.
  */
 @Internal
-public class InternalQueryAccess {
+public class InternalAccess {
 
-    /**
-     * For testing only.
-     */
+    @Internal
     public static <T> void nativeFindFirst(Query<T> query, long cursorHandle) {
         query.nativeFindFirst(query.handle, cursorHandle);
     }

tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java

@@ -36,7 +36,6 @@
 import io.objectbox.exception.DbException;
 import io.objectbox.exception.DbExceptionListener;
 import io.objectbox.exception.DbMaxReadersExceededException;
-import io.objectbox.query.InternalQueryAccess;
 import io.objectbox.query.Query;
 
 
@@ -339,15 +338,15 @@ public void nativeCallInTx_storeIsClosed_throws() throws InterruptedException {
             Box<TestEntity> box = store.boxFor(TestEntity.class);
             Query<TestEntity> query = box.query().build();
             // Obtain Cursor handle before closing the Store as getActiveTxCursor() has a closed check
-            long cursorHandle = io.objectbox.InternalAccess.getActiveTxCursorHandle(box);
+            long cursorHandle = InternalAccess.getActiveTxCursorHandle(box);
 
             callableIsReady.countDown();
             try {
                 if (!storeIsClosed.await(5, TimeUnit.SECONDS)) {
                     throw new IllegalStateException("Store did not close within 5 seconds");
                 }
                 // Call native query API within the transaction (opened by callInReadTx below)
-                InternalQueryAccess.nativeFindFirst(query, cursorHandle);
+                io.objectbox.query.InternalAccess.nativeFindFirst(query, cursorHandle);
                 query.close();
             } catch (Exception e) {
                 callableException.set(e);