Merge branch '43-rxjava3' into 'dev'

Resolve "Add new artifact supporting RxJava 3"

See merge request objectbox/objectbox-java!56

Author: greenrobot-team

Jenkinsfile

@@ -58,6 +58,7 @@ pipeline {
                         "--tests io.objectbox.FunctionalTestSuite " +
                         "--tests io.objectbox.test.proguard.ObfuscatedEntityTest " +
                         "--tests io.objectbox.rx.QueryObserverTest " +
+                        "--tests io.objectbox.rx3.QueryObserverTest " +
                         "spotbugsMain assemble"
             }
         }

build.gradle

@@ -20,6 +20,9 @@ buildscript {
         ob_native_dep = "io.objectbox:objectbox-$objectboxPlatform:$nativeVersion"
 
         junit_version = '4.13'
+        mockito_version = '3.3.3'
+        kotlin_version = '1.3.61'
+        dokka_version = '0.10.1'
 
         println "version=$ob_version"
         println "objectboxNativeDependency=$ob_native_dep"
@@ -34,6 +37,8 @@ buildscript {
     }
 
     dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
         classpath "gradle.plugin.com.github.spotbugs.snom:spotbugs-gradle-plugin:4.0.5"
     }
 }
@@ -64,7 +69,8 @@ def projectNamesToPublish = [
         'objectbox-java-api',
         'objectbox-java',
         'objectbox-kotlin',
-        'objectbox-rxjava'
+        'objectbox-rxjava',
+        'objectbox-rxjava3'
 ]
 
 def hasSigningProperties() {

objectbox-kotlin/build.gradle

@@ -1,17 +1,5 @@
 buildscript {
     ext.javadocDir = "$buildDir/docs/javadoc"
-    ext.kotlin_version = '1.3.61'
-    ext.dokka_version = '0.10.1'
-
-    repositories {
-        mavenCentral()
-        jcenter()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
-    }
 }
 
 apply plugin: 'kotlin'
@@ -63,6 +51,7 @@ dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
     compile project(':objectbox-java')
+    compileOnly project(':objectbox-rxjava3')
 }
 
 

objectbox-rxjava/README.md

@@ -1,3 +1,6 @@
+:information_source: This library will receive no new features.
+Development will continue with the [RxJava 3 APIs for ObjectBox](/objectbox-rxjava3).
+
 RxJava 2 APIs for ObjectBox
 ===========================
 While ObjectBox has [data observers and reactive extensions](https://docs.objectbox.io/data-observers-and-rx) built-in,
@@ -13,7 +16,7 @@ For general object changes, you can use `RxBoxStore` to create an `Observable`.
 For example to get query results and subscribe to future updates (Object changes will automatically emmit new data):
 
 ```java
-Query query = box.query().build();
+Query<User> query = box.query().build();
 RxQuery.observable(query).subscribe(this);
 ```
 
@@ -27,5 +30,3 @@ implementation "io.objectbox:objectbox-rxjava:$objectboxVersion"
 Links
 -----
 [Data Observers and Rx Documentation](https://docs.objectbox.io/data-observers-and-rx)
-
-[Note App example](https://github.com/objectbox/objectbox-examples/blob/master/objectbox-example/src/main/java/io/objectbox/example/ReactiveNoteActivity.java)

objectbox-rxjava/build.gradle

@@ -8,8 +8,7 @@ dependencies {
     compile 'io.reactivex.rxjava2:rxjava:2.2.18'
 
     testCompile "junit:junit:$junit_version"
-    // Mockito 3.x requires Java 8.
-    testCompile 'org.mockito:mockito-core:2.28.2'
+    testCompile "org.mockito:mockito-core:$mockito_version"
 }
 
 task javadocJar(type: Jar, dependsOn: javadoc) {

objectbox-rxjava3/README.md

@@ -0,0 +1,39 @@
+RxJava 3 APIs for ObjectBox
+===========================
+While ObjectBox has [data observers and reactive extensions](https://docs.objectbox.io/data-observers-and-rx) built-in,
+this project adds RxJava 3 support.  
+
+For general object changes, you can use `RxBoxStore` to create an `Observable`.
+
+`RxQuery` allows you to interact with ObjectBox `Query` objects using:
+ * Flowable
+ * Observable
+ * Single
+
+For example to get query results and subscribe to future updates (Object changes will automatically emmit new data):
+
+```java
+Query<User> query = box.query().build();
+RxQuery.observable(query).subscribe(this);
+```
+    
+Adding the library to your project
+-----------------
+Grab via Gradle:
+```gradle
+implementation "io.objectbox:objectbox-rxjava3:$objectboxVersion"
+```
+
+Migrating from RxJava 2
+-----------------------
+
+If you have previously used the ObjectBox RxJava library note the following changes:
+
+- The location of the dependency has changed to `objectbox-rxjava3` (see above).
+- The package name has changed to `io.objectbox.rx3` (from `io.objectbox.rx`).
+
+This should allow using both versions side-by-side while you migrate your code to RxJava 3.
+
+Links
+-----
+[Data Observers and Rx Documentation](https://docs.objectbox.io/data-observers-and-rx)

objectbox-rxjava3/build.gradle

@@ -0,0 +1,79 @@
+buildscript {
+    ext.javadocDir = "$buildDir/docs/javadoc"
+}
+
+apply plugin: 'java'
+apply plugin: 'kotlin'
+apply plugin: 'org.jetbrains.dokka'
+
+sourceCompatibility = JavaVersion.VERSION_1_8
+targetCompatibility = JavaVersion.VERSION_1_8
+
+// Produce Java 8 byte code, would default to Java 6.
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+dokka {
+    outputFormat = 'html'
+    outputDirectory = javadocDir
+
+    // Fix "Can't find node by signature": have to manually point to dependencies.
+    // https://github.com/Kotlin/dokka/wiki/faq#dokka-complains-about-cant-find-node-by-signature-
+    configuration{
+        externalDocumentationLink {
+            // Point to web javadoc for objectbox-java packages.
+            url = new URL("https://objectbox.io/docfiles/java/current/")
+            // Note: Using JDK 9+ package-list is now called element-list.
+            packageListUrl = new URL(url, "element-list")
+        }
+    }
+}
+
+dependencies {
+    compile project(':objectbox-java')
+    compile 'io.reactivex.rxjava3:rxjava:3.0.1'
+    compileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    testCompile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    testCompile "junit:junit:$junit_version"
+    testCompile "org.mockito:mockito-core:$mockito_version"
+}
+
+task javadocJar(type: Jar, dependsOn: dokka) {
+    classifier = 'javadoc'
+    from "$javadocDir"
+}
+
+task sourcesJar(type: Jar) {
+    from sourceSets.main.allSource
+    classifier = 'sources'
+}
+
+artifacts {
+    // java plugin adds jar.
+    archives javadocJar
+    archives sourcesJar
+}
+
+uploadArchives {
+    repositories {
+        mavenDeployer {
+            // Basic definitions are defined in root project
+            pom.project {
+                name 'ObjectBox RxJava 3 API'
+                description 'RxJava 3 extensions for ObjectBox'
+
+                licenses {
+                    license {
+                        name 'The Apache Software License, Version 2.0'
+                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                        distribution 'repo'
+                    }
+                }
+            }
+        }
+    }
+}

objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt

@@ -0,0 +1,28 @@
+package io.objectbox.rx3
+
+import io.objectbox.query.Query
+import io.reactivex.rxjava3.core.BackpressureStrategy
+import io.reactivex.rxjava3.core.Flowable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+
+/**
+ * Shortcut for [`RxQuery.flowableOneByOne(query, strategy)`][RxQuery.flowableOneByOne].
+ */
+fun <T> Query<T>.flowableOneByOne(strategy: BackpressureStrategy = BackpressureStrategy.BUFFER): Flowable<T> {
+    return RxQuery.flowableOneByOne(this, strategy)
+}
+
+/**
+ * Shortcut for [`RxQuery.observable(query)`][RxQuery.observable].
+ */
+fun <T> Query<T>.observable(): Observable<MutableList<T>> {
+    return RxQuery.observable(this)
+}
+
+/**
+ * Shortcut for [`RxQuery.single(query)`][RxQuery.single].
+ */
+fun <T> Query<T>.single(): Single<MutableList<T>> {
+    return RxQuery.single(this)
+}

objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java

@@ -0,0 +1,43 @@
+/*
+ * 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.rx3;
+
+import io.objectbox.BoxStore;
+import io.objectbox.reactive.DataSubscription;
+import io.reactivex.rxjava3.core.Observable;
+
+/**
+ * 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.
+     */
+    @SuppressWarnings("rawtypes") // BoxStore observer may return any (entity) type.
+    public static Observable<Class> observable(BoxStore boxStore) {
+        return Observable.create(emitter -> {
+            final DataSubscription dataSubscription = boxStore.subscribe().observer(data -> {
+                if (!emitter.isDisposed()) {
+                    emitter.onNext(data);
+                }
+            });
+            emitter.setCancellable(dataSubscription::cancel);
+        });
+    }
+
+}

objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java

@@ -0,0 +1,94 @@
+/*
+ * 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.rx3;
+
+import java.util.List;
+
+import io.objectbox.query.Query;
+import io.objectbox.reactive.DataSubscription;
+import io.reactivex.rxjava3.core.BackpressureStrategy;
+import io.reactivex.rxjava3.core.Flowable;
+import io.reactivex.rxjava3.core.FlowableEmitter;
+import io.reactivex.rxjava3.core.Observable;
+import io.reactivex.rxjava3.core.Single;
+
+/**
+ * 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(emitter -> createListItemEmitter(query, emitter), strategy);
+    }
+
+    static <T> void createListItemEmitter(final Query<T> query, final FlowableEmitter<T> emitter) {
+        final DataSubscription dataSubscription = query.subscribe().observer(data -> {
+            for (T datum : data) {
+                if (emitter.isCancelled()) {
+                    return;
+                } else {
+                    emitter.onNext(datum);
+                }
+            }
+            if (!emitter.isCancelled()) {
+                emitter.onComplete();
+            }
+        });
+        emitter.setCancellable(dataSubscription::cancel);
+    }
+
+    /**
+     * The returned Observable emits Query results as Lists.
+     * Never completes, so you will get updates when underlying data changes
+     * (see {@link Query#subscribe()} for details).
+     */
+    public static <T> Observable<List<T>> observable(final Query<T> query) {
+        return Observable.create(emitter -> {
+            final DataSubscription dataSubscription = query.subscribe().observer(data -> {
+                if (!emitter.isDisposed()) {
+                    emitter.onNext(data);
+                }
+            });
+            emitter.setCancellable(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(emitter -> {
+            query.subscribe().single().observer(data -> {
+                if (!emitter.isDisposed()) {
+                    emitter.onSuccess(data);
+                }
+            });
+            // no need to cancel, single never subscribes
+        });
+    }
+}