Merge branch 'sync' into dev

Author: greenrobot

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

@@ -0,0 +1,17 @@
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Enables sync for an {@link Entity} class.
+ * <p>
+ * Note that currently sync can not be enabled or disabled for existing entities.
+ * Also synced entities can not have relations to non-synced entities.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.TYPE)
+public @interface Sync {
+}

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

@@ -21,6 +21,8 @@
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -51,6 +53,7 @@
 import io.objectbox.reactive.DataObserver;
 import io.objectbox.reactive.DataPublisher;
 import io.objectbox.reactive.SubscriptionBuilder;
+import io.objectbox.sync.SyncClient;
 
 /**
  * An ObjectBox database that provides {@link Box Boxes} to put and get Objects of a specific Entity class
@@ -169,19 +172,45 @@ static native void nativeRegisterCustomType(long store, int entityId, int proper
 
     static native void nativeSetDebugFlags(long store, int debugFlags);
 
-    static native String nativeStartObjectBrowser(long store, @Nullable String urlPath, int port);
+    private native String nativeStartObjectBrowser(long store, @Nullable String urlPath, int port);
+
+    private native boolean nativeStopObjectBrowser(long store);
 
     static native boolean nativeIsObjectBrowserAvailable();
 
     native long nativeSizeOnDisk(long store);
 
     native long nativeValidate(long store, long pageLimit, boolean checkLeafLevel);
 
+    static native int nativeGetSupportedSync();
+
     public static boolean isObjectBrowserAvailable() {
         NativeLibraryLoader.ensureLoaded();
         return nativeIsObjectBrowserAvailable();
     }
 
+    private static int getSupportedSync() {
+        NativeLibraryLoader.ensureLoaded();
+        try {
+            int supportedSync = nativeGetSupportedSync();
+            if (supportedSync < 0 || supportedSync > 2) {
+                throw new IllegalStateException("Unexpected sync support: " + supportedSync);
+            }
+            return supportedSync;
+        } catch (UnsatisfiedLinkError e) {
+            System.err.println("Old JNI lib? " + e);  // No stack
+            return 0;
+        }
+    }
+
+    public static boolean isSyncAvailable() {
+        return getSupportedSync() != 0;
+    }
+
+    public static boolean isSyncServerAvailable() {
+        return getSupportedSync() == 2;
+    }
+
     native long nativePanicModeRemoveAllObjects(long store, int entityId);
 
     private final File directory;
@@ -216,6 +245,12 @@ public static boolean isObjectBrowserAvailable() {
 
     private final TxCallback<?> failedReadTxAttemptCallback;
 
+    /**
+     * Keeps a reference so the library user does not have to.
+     */
+    @Nullable
+    private SyncClient syncClient;
+
     BoxStore(BoxStoreBuilder builder) {
         context = builder.context;
         relinker = builder.relinker;
@@ -489,6 +524,14 @@ public void close() {
         synchronized (this) {
             oldClosedState = closed;
             if (!closed) {
+                if(objectBrowserPort != 0) { // not linked natively (yet), so clean up here
+                    try {
+                        stopObjectBrowser();
+                    } catch (Throwable e) {
+                        e.printStackTrace();
+                    }
+                }
+
                 // Closeable recommendation: mark as closed before any code that might throw.
                 closed = true;
                 List<Transaction> transactionsToClose;
@@ -1015,11 +1058,41 @@ public String startObjectBrowser(int port) {
         return url;
     }
 
+    @Experimental
+    @Nullable
+    public String startObjectBrowser(String urlToBindTo) {
+        verifyObjectBrowserNotRunning();
+        int port;
+        try {
+            port = new URL(urlToBindTo).getPort(); // Gives -1 if not available
+        } catch (MalformedURLException e) {
+            throw new RuntimeException("Can not start Object Browser at " + urlToBindTo, e);
+        }
+        String url = nativeStartObjectBrowser(handle, urlToBindTo, 0);
+        if (url != null) {
+            objectBrowserPort = port;
+        }
+        return url;
+    }
+
+    @Experimental
+    public synchronized boolean stopObjectBrowser() {
+        if(objectBrowserPort == 0) {
+            throw new IllegalStateException("ObjectBrowser has not been started before");
+        }
+        objectBrowserPort = 0;
+        return nativeStopObjectBrowser(handle);
+    }
+
     @Experimental
     public int getObjectBrowserPort() {
         return objectBrowserPort;
     }
 
+    public boolean isObjectBrowserRunning() {
+        return objectBrowserPort != 0;
+    }
+
     private void verifyObjectBrowserNotRunning() {
         if (objectBrowserPort != 0) {
             throw new DbException("ObjectBrowser is already running at port " + objectBrowserPort);
@@ -1097,4 +1170,15 @@ public long getNativeStore() {
         return handle;
     }
 
+    /**
+     * Returns the {@link SyncClient} associated with this store. To create one see {@link io.objectbox.sync.Sync Sync}.
+     */
+    @Nullable
+    public SyncClient getSyncClient() {
+        return syncClient;
+    }
+
+    void setSyncClient(@Nullable SyncClient syncClient) {
+        this.syncClient = syncClient;
+    }
 }

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

@@ -16,14 +16,21 @@
 
 package io.objectbox;
 
+import javax.annotation.Nullable;
+
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.SyncClient;
 
 @Internal
 public class InternalAccess {
     public static <T> Cursor<T> getReader(Box<T> box) {
         return box.getReader();
     }
 
+    public static long getHandle(BoxStore boxStore) {
+        return boxStore.internalHandle();
+    }
+
     public static long getHandle(Cursor reader) {
         return reader.internalHandle();
     }
@@ -32,6 +39,10 @@ public static long getHandle(Transaction tx) {
         return tx.internalHandle();
     }
 
+    public static void setSyncClient(BoxStore boxStore, @Nullable SyncClient syncClient) {
+        boxStore.setSyncClient(syncClient);
+    }
+
     public static <T> void releaseReader(Box<T> box, Cursor<T> reader) {
         box.releaseReader(reader);
     }

objectbox-java/src/main/java/io/objectbox/sync/ConnectivityMonitor.java

@@ -0,0 +1,52 @@
+package io.objectbox.sync;
+
+import javax.annotation.Nullable;
+
+/**
+ * Used by {@link SyncClient} to observe connectivity changes.
+ * <p>
+ * Implementations are provided by a {@link io.objectbox.sync.internal.Platform platform}.
+ */
+public abstract class ConnectivityMonitor {
+
+    @Nullable
+    private SyncClient syncClient;
+
+    void setObserver(SyncClient syncClient) {
+        //noinspection ConstantConditions Annotations do not enforce non-null.
+        if (syncClient == null) {
+            throw new IllegalArgumentException("Sync client must not be null");
+        }
+        this.syncClient = syncClient;
+        onObserverSet();
+    }
+
+    void removeObserver() {
+        this.syncClient = null;
+        onObserverRemoved();
+    }
+
+    /**
+     * Called right after the observer was set.
+     */
+    public void onObserverSet() {
+    }
+
+    /**
+     * Called right after the observer was removed.
+     */
+    public void onObserverRemoved() {
+    }
+
+    /**
+     * Notifies the observer that a connection is available.
+     * Implementers should call this once a working network connection is available.
+     */
+    public final void notifyConnectionAvailable() {
+        SyncClient syncClient = this.syncClient;
+        if (syncClient != null) {
+            syncClient.notifyConnectionAvailable();
+        }
+    }
+
+}

objectbox-java/src/main/java/io/objectbox/sync/Sync.java

@@ -0,0 +1,41 @@
+package io.objectbox.sync;
+
+import io.objectbox.BoxStore;
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.sync.server.SyncServerBuilder;
+
+/**
+ * Start building a sync client using Sync.{@link #client(BoxStore, String, SyncCredentials)}
+ * or a server using Sync.{@link #server(BoxStore, String, SyncCredentials)}.
+ */
+@SuppressWarnings({"unused", "WeakerAccess"})
+@Experimental
+public final class Sync {
+
+    /**
+     * Returns true if the included native (JNI) ObjectBox library supports sync.
+     */
+    public static boolean isAvailable() {
+        return BoxStore.isSyncAvailable();
+    }
+
+    /**
+     * Start building a sync client. Requires the BoxStore that should be synced with the server,
+     * the URL and port of the server to connect to and credentials to authenticate against the server.
+     */
+    public static SyncBuilder client(BoxStore boxStore, String url, SyncCredentials credentials) {
+        return new SyncBuilder(boxStore, url, credentials);
+    }
+
+    /**
+     * Start building a sync server. Requires the BoxStore the server should use,
+     * the URL and port the server should bind to and authenticator credentials to authenticate clients.
+     * Additional authenticator credentials can be supplied using the builder.
+     */
+    public static SyncServerBuilder server(BoxStore boxStore, String url, SyncCredentials authenticatorCredentials) {
+        return new SyncServerBuilder(boxStore, url, authenticatorCredentials);
+    }
+
+    private Sync() {
+    }
+}