Move objectbox-rxjava into this repository.

greenrobot-team · greenrobot-team · commit 3b06401f75c8 · 2018-07-03T13:22:03.000+02:00
diff --git a/build.gradle b/build.gradle
@@ -42,6 +42,7 @@ def projectNamesToPublish =
          'objectbox-java-api',
          'objectbox-java',
          'objectbox-kotlin',
+         'objectbox-rxjava',
          'objectbox-generator',
          'objectbox-daocompat',
          'linux',
@@ -139,6 +140,7 @@ task installAll {
     dependsOn ':objectbox-java-api:install'
     dependsOn ':objectbox-java:install'
     dependsOn ':objectbox-kotlin:install'
+    dependsOn ':objectbox-rxjava:install'
     doLast {
         println("Installed version $version")
     }
@@ -150,6 +152,7 @@ task deployAll {
     dependsOn ':objectbox-java-api:uploadArchives'
     dependsOn ':objectbox-java:uploadArchives'
     dependsOn ':objectbox-kotlin:uploadArchives'
+    dependsOn ':objectbox-rxjava:uploadArchives'
 }
 
 // this task is also used by the composite build ('objectbox-deploy'), check before making changes
diff --git a/objectbox-rxjava/build.gradle b/objectbox-rxjava/build.gradle
@@ -0,0 +1,63 @@
+apply plugin: 'java'
+
+group = 'io.objectbox'
+version= rootProject.version
+
+sourceCompatibility = 1.7
+
+dependencies {
+    compile project(':objectbox-java')
+    compile 'io.reactivex.rxjava2:rxjava:2.0.6'
+
+    testCompile 'junit:junit:4.12'
+    testCompile 'org.mockito:mockito-core:2.7.10'
+}
+
+javadoc {
+    failOnError = false
+    title = "ObjectBox RxJava2 ${version} API"
+    excludes = [] // Unfinished APIs if any
+    options.bottom = 'Available under the Apache License, Version 2.0 - <i>Copyright &#169; 2017 <a href="http://objectbox.io/">ObjectBox Ltd</a>. All Rights Reserved.</i>'
+    doLast {
+        copy {
+            from '../javadoc-style/'
+            into "build/docs/javadoc/"
+        }
+    }
+}
+
+task javadocJar(type: Jar, dependsOn: javadoc) {
+    classifier = 'javadoc'
+    from 'build/docs/javadoc'
+}
+
+task sourcesJar(type: Jar) {
+    from sourceSets.main.allSource
+    classifier = 'sources'
+}
+
+artifacts {
+    archives jar
+    archives javadocJar
+    archives sourcesJar
+}
+
+uploadArchives {
+    repositories {
+        mavenDeployer {
+            // Basic definitions are defined in root project
+            pom.project {
+                name 'ObjectBox RxJava API'
+                description 'RxJava extension for ObjectBox'
+
+                licenses {
+                    license {
+                        name 'The Apache Software License, Version 2.0'
+                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                        distribution 'repo'
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ *
+ * 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.rx;
+
+import io.objectbox.BoxStore;
+import io.objectbox.reactive.DataObserver;
+import io.objectbox.reactive.DataSubscription;
+import io.reactivex.Observable;
+import io.reactivex.ObservableEmitter;
+import io.reactivex.ObservableOnSubscribe;
+import io.reactivex.functions.Cancellable;
+
+/**
+ * Static methods to Rx-ify ObjectBox queries.
+ */
+public abstract class RxBoxStore {
+    /**
+     * Using the returned Observable, you can be notified about data changes.
+     * Once a transaction is committed, you will get info on classes with changed Objects.
+     */
+    public static <T> Observable<Class> observable(final BoxStore boxStore) {
+        return Observable.create(new ObservableOnSubscribe<Class>() {
+            @Override
+            public void subscribe(final ObservableEmitter<Class> emitter) throws Exception {
+                final DataSubscription dataSubscription = boxStore.subscribe().observer(new DataObserver<Class>() {
+                    @Override
+                    public void onData(Class data) {
+                        if (!emitter.isDisposed()) {
+                            emitter.onNext(data);
+                        }
+                    }
+                });
+                emitter.setCancellable(new Cancellable() {
+                    @Override
+                    public void cancel() throws Exception {
+                        dataSubscription.cancel();
+                    }
+                });
+            }
+        });
+    }
+
+}
diff --git a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ *
+ * 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.rx;
+
+import java.util.List;
+
+import io.objectbox.query.Query;
+import io.objectbox.reactive.DataObserver;
+import io.objectbox.reactive.DataSubscription;
+import io.reactivex.BackpressureStrategy;
+import io.reactivex.Flowable;
+import io.reactivex.FlowableEmitter;
+import io.reactivex.FlowableOnSubscribe;
+import io.reactivex.Observable;
+import io.reactivex.ObservableEmitter;
+import io.reactivex.ObservableOnSubscribe;
+import io.reactivex.Single;
+import io.reactivex.SingleEmitter;
+import io.reactivex.SingleOnSubscribe;
+import io.reactivex.functions.Cancellable;
+
+/**
+ * Static methods to Rx-ify ObjectBox queries.
+ */
+public abstract class RxQuery {
+    /**
+     * The returned Flowable emits Query results one by one. Once all results have been processed, onComplete is called.
+     * Uses BackpressureStrategy.BUFFER.
+     */
+    public static <T> Flowable<T> flowableOneByOne(final Query<T> query) {
+        return flowableOneByOne(query, BackpressureStrategy.BUFFER);
+    }
+
+    /**
+     * The returned Flowable emits Query results one by one. Once all results have been processed, onComplete is called.
+     * Uses given BackpressureStrategy.
+     */
+    public static <T> Flowable<T> flowableOneByOne(final Query<T> query, BackpressureStrategy strategy) {
+        return Flowable.create(new FlowableOnSubscribe<T>() {
+            @Override
+            public void subscribe(final FlowableEmitter<T> emitter) throws Exception {
+                createListItemEmitter(query, emitter);
+            }
+
+        }, strategy);
+    }
+
+    static <T> void createListItemEmitter(final Query<T> query, final FlowableEmitter<T> emitter) {
+        final DataSubscription dataSubscription = query.subscribe().observer(new DataObserver<List<T>>() {
+            @Override
+            public void onData(List<T> data) {
+                for (T datum : data) {
+                    if (emitter.isCancelled()) {
+                        return;
+                    } else {
+                        emitter.onNext(datum);
+                    }
+                }
+                if (!emitter.isCancelled()) {
+                    emitter.onComplete();
+                }
+            }
+        });
+        emitter.setCancellable(new Cancellable() {
+            @Override
+            public void cancel() throws Exception {
+                dataSubscription.cancel();
+            }
+        });
+    }
+
+    /**
+     * The returned Observable emits Query results as Lists.
+     * Never completes, so you will get updates when underlying data changes.
+     */
+    public static <T> Observable<List<T>> observable(final Query<T> query) {
+        return Observable.create(new ObservableOnSubscribe<List<T>>() {
+            @Override
+            public void subscribe(final ObservableEmitter<List<T>> emitter) throws Exception {
+                final DataSubscription dataSubscription = query.subscribe().observer(new DataObserver<List<T>>() {
+                    @Override
+                    public void onData(List<T> data) {
+                        if (!emitter.isDisposed()) {
+                            emitter.onNext(data);
+                        }
+                    }
+                });
+                emitter.setCancellable(new Cancellable() {
+                    @Override
+                    public void cancel() throws Exception {
+                        dataSubscription.cancel();
+                    }
+                });
+            }
+        });
+    }
+
+    /**
+     * The returned Single emits one Query result as a List.
+     */
+    public static <T> Single<List<T>> single(final Query<T> query) {
+        return Single.create(new SingleOnSubscribe<List<T>>() {
+            @Override
+            public void subscribe(final SingleEmitter<List<T>> emitter) throws Exception {
+                query.subscribe().single().observer(new DataObserver<List<T>>() {
+                    @Override
+                    public void onData(List<T> data) {
+                        if (!emitter.isDisposed()) {
+                            emitter.onSuccess(data);
+                        }
+                    }
+                });
+                // no need to cancel, single never subscribes
+            }
+        });
+    }
+}
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java b/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ *
+ * 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.query;
+
+import io.objectbox.reactive.DataObserver;
+import io.objectbox.reactive.DataPublisher;
+import io.objectbox.reactive.DataPublisherUtils;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+public class FakeQueryPublisher<T> implements DataPublisher<List<T>> {
+
+    private final Set<DataObserver<List<T>>> observers = new CopyOnWriteArraySet();
+
+    private List<T> queryResult = Collections.emptyList();
+
+    public List<T> getQueryResult() {
+        return queryResult;
+    }
+
+    public void setQueryResult(List<T> queryResult) {
+        this.queryResult = queryResult;
+    }
+
+    @Override
+    public synchronized void subscribe(DataObserver<List<T>> observer, Object param) {
+        observers.add(observer);
+    }
+
+    @Override
+    public void publishSingle(final DataObserver<List<T>> observer, Object param) {
+        observer.onData(queryResult);
+    }
+
+    public void publish() {
+        for (DataObserver<List<T>> observer : observers) {
+            observer.onData(queryResult);
+        }
+    }
+
+    @Override
+    public synchronized void unsubscribe(DataObserver<List<T>> observer, Object param) {
+        DataPublisherUtils.removeObserverFromCopyOnWriteSet(observers, observer);
+    }
+
+}
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java b/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ *
+ * 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.query;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.objectbox.Box;
+import io.objectbox.BoxStore;
+import io.objectbox.reactive.SubscriptionBuilder;
+
+public class MockQuery<T> {
+    private Box box;
+    private BoxStore boxStore;
+    private final Query query;
+    private final FakeQueryPublisher fakeQueryPublisher;
+
+    public MockQuery(boolean hasOrder) {
+        // box = mock(Box.class);
+        // boxStore = mock(BoxStore.class);
+        // when(box.getStore()).thenReturn(boxStore);
+         query = mock(Query.class);
+        fakeQueryPublisher = new FakeQueryPublisher();
+        SubscriptionBuilder subscriptionBuilder = new SubscriptionBuilder(fakeQueryPublisher, null, null);
+        when(query.subscribe()).thenReturn(subscriptionBuilder);
+    }
+
+    public Box getBox() {
+        return box;
+    }
+
+    public BoxStore getBoxStore() {
+        return boxStore;
+    }
+
+    public Query getQuery() {
+        return query;
+    }
+
+    public FakeQueryPublisher getFakeQueryPublisher() {
+        return fakeQueryPublisher;
+    }
+}
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java b/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java
diff --git a/settings.gradle b/settings.gradle
