Share
Rx in Multiplatformland (MobileOptimized 2019)
File with original colors can be downloaded here: https://bit.ly/2N1wlF6
Reactive programming has firmly become one of the modern Android developer's tools. More and more teams apply fully reactive architectures for their apps utilizing MV* approaches. This plays well for separating our OS-independent business logic from presentation layer. And while it can be implemented really nice using Kotlin, what if we want to expand this solid base further and don't repeat ourselves on every platform? What if we want to enter Multiplatformland?
Obviously, our best friend, RxJava, is not ready for that journey. But do we really have no alternatives? In this talk we'll discuss multiplatform friends of RxJava, such as Flow from Kotlin team and Reaktive from Badoo, their pros & cons, and how usable are they for our tasks.
Video: https://youtu.be/FazAHlmlwws
Sergey Ryabov
Transcript
73 slides
-
Last year at Mobius ✦ "How to cook a well
done MVI for Android" talk1 ✦ Platform-agnostic ✦ Based on Kotlin. MPP! ! ✦ Based on RxJava. MPP? " ✦ Maybe RxKotlin? (for real) 1 https:/ /www.youtube.com/watch?v=hBkQkjWnAjg -
This year ✦ In March my friend Kostya sent me
a link to a Reaktive repo ✦ In April Roman wrote an article about Flow Preview2 2 https:/ /medium.com/@elizarov/cold-flows-hot-channels-d74769805f9 -
Fast-forward 6 months ✦ Reaktive - 1.0.1 ✦ Flow -
stable since Coroutines 1.3.0 ✦ Supported by SQLDelight 1.2.0 ✦ Supported by Room 2.2.0 -
RxJava2 Observable.just(1, 2, 3) .filter { it % 2 ==
0 } .map { it * 10 } .subscribe { println(it) } -
Reaktive observableOf(1, 2, 3) .filter { it % 2 ==
0 } .map { it * 10 } .subscribe { println(it) } -
Flow flowOf(1, 2, 3) .filter { it % 2 ==
0 } .map { it * 10 } .collect { println(it) } -
Flow flowOf(1, 2, 3) .filter { it % 2 ==
0 } .map { it * 10 } .collect { println(it) } -
Flow. In a nutshell interface Flow<out T> { suspend fun
collect(collector: FlowCollector<T>) } interface FlowCollector<in T> { suspend fun emit(value: T) } -
How does it work? Flow fun <T, R> Flow<T>.map(transform: suspend
(value: T) -> R): Flow<R> = flow { collect { value -> emit(transform(value)) } } -
How does it work? Flow fun <T, R> Flow<T>.map(transform: suspend
(value: T) -> R): Flow<R> = flow { this: FlowCollector -> [email protected] { value -> this.emit(transform(value)) } } -
How does it work? Flow fun <T, R> Flow<T>.map(transform: suspend
(value: T) -> R): Flow<R> = flow { this: FlowCollector -> [email protected] { value -> this.emit(transform(value)) } } -
How does it work? Flow fun <T, R> Flow<T>.map(transform: suspend
(value: T) -> R): Flow<R> = flow { this: FlowCollector -> [email protected] { value -> this.emit(transform(value)) } } -
How does it work? Flow fun <T, R> Flow<T>.map(transform: suspend
(value: T) -> R): Flow<R> = flow { this: FlowCollector -> [email protected] { value -> this.emit(transform(value)) } } -
How does it work? Flow fun <T, R> Flow<T>.map(transform: suspend
(value: T) -> R): Flow<R> = flow { this: FlowCollector -> [email protected] { value -> this.emit(transform(value)) } } -
How does it work? Reaktive fun <T, R> Observable<T>.map(mapper: (T)
-> R): Observable<R> = observable { emitter -> subscribeSafe( object : ObservableObserver<T>, CompletableCallbacks by emitter { override fun onSubscribe(disposable: Disposable) { emitter.setDisposable(disposable) } override fun onNext(value: T) { emitter.tryCatch(block = { mapper(value) }, onSuccess = emitter::onNext) } } ) } -
How does it work? Reaktive fun <T, R> Observable<T>.map(mapper: (T)
-> R): Observable<R> = observable { emitter -> subscribeSafe( object : ObservableObserver<T>, CompletableCallbacks by emitter { override fun onSubscribe(disposable: Disposable) { emitter.setDisposable(disposable) } override fun onNext(value: T) { emitter.tryCatch(block = { mapper(value) }, onSuccess = emitter::onNext) } } ) } -
How does it work? Reaktive fun <T, R> Observable<T>.map(mapper: (T)
-> R): Observable<R> = observable { emitter -> subscribeSafe( object : ObservableObserver<T>, CompletableCallbacks by emitter { override fun onSubscribe(disposable: Disposable) { emitter.setDisposable(disposable) } override fun onNext(value: T) { emitter.tryCatch(block = { mapper(value) }, onSuccess = emitter::onNext) } } ) } -
How does it work? Reaktive fun <T, R> Observable<T>.map(mapper: (T)
-> R): Observable<R> = observable { emitter -> subscribeSafe( object : ObservableObserver<T>, CompletableCallbacks by emitter { override fun onSubscribe(disposable: Disposable) { emitter.setDisposable(disposable) } override fun onNext(value: T) { emitter.tryCatch(block = { mapper(value) }, onSuccess = emitter::onNext) } } ) } -
How does it work? Reaktive fun <T, R> Observable<T>.map(mapper: (T)
-> R): Observable<R> = observable { emitter -> subscribeSafe( object : ObservableObserver<T>, CompletableCallbacks by emitter { override fun onSubscribe(disposable: Disposable) { emitter.setDisposable(disposable) } override fun onNext(value: T) { emitter.tryCatch(block = { mapper(value) }, onSuccess = emitter::onNext) } } ) } -
How does it work? Reaktive fun <T, R> Observable<T>.map(mapper: (T)
-> R): Observable<R> = observable { emitter -> subscribeSafe( object : ObservableObserver<T>, CompletableCallbacks by emitter { override fun onSubscribe(disposable: Disposable) { emitter.setDisposable(disposable) } override fun onNext(value: T) { emitter.tryCatch(block = { mapper(value) }, onSuccess = emitter::onNext) } } ) } -
How does it work? Reaktive fun <T, R> Observable<T>.map(mapper: (T)
-> R): Observable<R> = observable { emitter -> subscribeSafe( object : ObservableObserver<T>, CompletableCallbacks by emitter { override fun onSubscribe(disposable: Disposable) { emitter.setDisposable(disposable) } override fun onNext(value: T) { emitter.tryCatch(block = { mapper(value) }, onSuccess = emitter::onNext) } } ) } -
How does it work? RxJa... oh, damn public final class
ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> { final Function<? super T, ? extends U> function; public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) { super(source); this.function = function; } @Override public void subscribeActual(Observer<? super U> t) { source.subscribe(new MapObserver<T, U>(t, function)); } static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> { final Function<? super T, ? extends U> mapper; MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) { super(actual); this.mapper = mapper; } @Override public void onNext(T t) { if (done) { return; } if (sourceMode != NONE) { downstream.onNext(null); return; } U v; try { v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value."); } catch (Throwable ex) { fail(ex); return; } downstream.onNext(v); } @Override public int requestFusion(int mode) { return transitiveBoundaryFusion(mode); } @Nullable @Override public U poll() throws Exception { T t = qd.poll(); return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null; } } } -
Operators Reaktive Flow flatMap flatMapMerge concatMap flatMapConcat switchMap flatMapLatest flatten
flattenConcat merge flattenMerge combineLatest combine skip drop onError* catch ... ... -
Missing in Flow ✦ groupBy ✦ publish ✦ share 3
✦ replay ✦ withLatestFrom ✦ takeUntil ✦ parallel 3 https:/ /github.com/Kotlin/kotlinx.coroutines/issues/1261 -
Missing in Flow ✦ groupBy 5 ✦ publish 5 ✦
share ✦ replay 5 ✦ withLatestFrom ✦ takeUntil 5 ✦ parallel 5 5 https:/ /github.com/akarnokd/kotlin-flow-extensions -
Threading. Reaktive observableOf(1, 2, 3) .filter { it % 2
== 0 } .subscribeOn(ioScheduler) .observeOn(computationScheduler) .map { it * 10 } .observeOn(mainScheduler) .subscribe { println(it) } -
Threading. Reaktive observableOf(1, 2, 3) .filter { it % 2
== 0 } .subscribeOn(ioScheduler) .observeOn(computationScheduler) .map { it * 10 } .observeOn(mainScheduler) .subscribe { println(it) } -
Threading. Reaktive observableOf(1, 2, 3) .filter { it % 2
== 0 } .subscribeOn(ioScheduler) .observeOn(computationScheduler) .map { it * 10 } .observeOn(mainScheduler) .subscribe { println(it) } -
Threading. Reaktive observableOf(1, 2, 3) .filter { it % 2
== 0 } .subscribeOn(ioScheduler) .observeOn(computationScheduler) .map { it * 10 } .observeOn(mainScheduler) .subscribe { println(it) } -
Threading. Reaktive observableOf(1, 2, 3) .filter { it % 2
== 0 } .subscribeOn(ioScheduler) .observeOn(computationScheduler) .map { it * 10 } .observeOn(mainScheduler) .subscribe { println(it) } -
Threading. Reaktive observableOf(1, 2, 3) .filter { it % 2
== 0 } .subscribeOn(ioScheduler) .observeOn(computationScheduler) .map { it * 10 } .observeOn(mainScheduler) .subscribe { println(it) } -
Threading. Reaktive observableOf(1, 2, 3) .filter { it % 2
== 0 } .subscribeOn(ioScheduler) .observeOn(computationScheduler) .map { it * 10 } .observeOn(mainScheduler) .subscribe { println(it) } -
Threading. Flow scope.launch(Dispatchers.MAIN) { flowOf(1, 2, 3) .filter { it
% 2 == 0 } .flowOn(Dispatchers.IO) .map { it * 10 } .flowOn(Dispatchers.Default) .collect { println(it) } } -
Threading. Flow scope.launch(Dispatchers.MAIN) { flowOf(1, 2, 3) .filter { it
% 2 == 0 } .flowOn(Dispatchers.IO) .map { it * 10 } .flowOn(Dispatchers.Default) .collect { println(it) } } -
Threading. Flow scope.launch(Dispatchers.MAIN) { flowOf(1, 2, 3) .filter { it
% 2 == 0 } .flowOn(Dispatchers.IO) .map { it * 10 } .flowOn(Dispatchers.Default) .collect { println(it) } } -
Threading. Flow scope.launch(Dispatchers.MAIN) { flowOf(1, 2, 3) .filter { it
% 2 == 0 } .flowOn(Dispatchers.IO) .map { it * 10 } .flowOn(Dispatchers.Default) .collect { println(it) } } -
Threading. Flow scope.launch(Dispatchers.MAIN) { flowOf(1, 2, 3) .filter { it
% 2 == 0 } .flowOn(Dispatchers.IO) .map { it * 10 } .flowOn(Dispatchers.Default) .collect { println(it) } } -
Threading. Flow scope.launch(Dispatchers.MAIN) { flowOf(1, 2, 3) .filter { it
% 2 == 0 } .flowOn(Dispatchers.IO) .map { it * 10 } .flowOn(Dispatchers.Default) .collect { println(it) } } -
Threading. Flow scope.launch(Dispatchers.MAIN) { flowOf(1, 2, 3) .filter { it
% 2 == 0 } .flowOn(Dispatchers.IO) .map { it * 10 } .flowOn(Dispatchers.Default) .collect { println(it) } } -
Schedulers RxJava2 Reaktive Flow AndroidSchedulers.mainThread() mainScheduler Dispatchers.MAIN Schedulers.io() ioScheduler Dispatchers.IO
6 Schedulers.computation() computationScheduler Dispatchers.Default Schedulers.trampoline() trampolineScheduler Executor.asCoroutineDispatcher() 6 Schedulers.newThread() i.r.Scheduler.asReaktive() 6 Executor.asCoroutineDispatcher() 6 Schedulers.single() i.r.Scheduler.asReaktive() 6 Executor.asCoroutineDispatcher() 6 6 only on JVM -
Subjects ✦ RxJava2: Behavior, Publish, Replay ✦ Reaktive: Behavior, Publish
✦ Flow: Behavior (ConflatedBroadcastChannel 7) ✦ Flow + Karnok5: Behavior, Publish, Replay 5 https:/ /github.com/akarnokd/kotlin-flow-extensions 7 DataFlow Proposal: https:/ /github.com/Kotlin/kotlinx.coroutines/pull/1354 -
Interop & Gradual adoption Adapter artifacts: ✦ org.jetbrains.kotlinx:kotlinx-coroutines-rx2 ✦ com.badoo.reaktive:coroutines-interop
✦ com.badoo.reaktive:rxjava2-interop -
Interop & Gradual adoption. Flow Check this out: kotlinx-coroutines-core/common/src/flow/Migration.kt Deprecated(
level = DeprecationLevel.ERROR, message = "Flow analogue of 'flatten' is 'flattenConcat'", replaceWith = ReplaceWith("flattenConcat()") ) fun <T> Flow<Flow<T>>.flatten(): Flow<T> = noImpl() -
Error handling bits dataObservable() .flatMap { crashMap(it) } .subscribe( onNext
= { handle(it) }, onError = { report(it) } ) -
Error handling bits dataObservable() .flatMap { map(it) } .subscribe( onNext
= { crashHandle(it) }, onError = { report(it) } ) -
Error handling bits. Flow dataFlow() .flatMap { map(it) } .subscribe(
onNext = { crashHandle(it) }, onError = { report(it) } ) -
Error handling bits. Flow dataFlow() .flatMapMerge { map(it) } .subscribe(
onNext = { crashHandle(it) }, onError = { report(it) } ) -
Error handling bits. Flow dataFlow() .flatMapMerge { map(it) } .catch
{ report(it) } .subscribe( onNext = { crashHandle(it) } ) -
Error handling bits. Flow dataFlow() .flatMapMerge { map(it) } .catch
{ report(it) } .collect { crashHandle(it) } -
Error handling bits. Flow dataFlow() .flatMapMerge { map(it) } .catch
{ report(it) } .collect { crashHandle(it) } We crash! -
Error handling bits. Flow dataFlow() .flatMapMerge { map(it) } .onEach
{ crashHandle(it) } .catch { report(it) } .collect() -
Error handling bits. Flow dataFlow() .flatMapMerge { map(it) } .onEach
{ crashHandle(it) } .catch { report(it) } .collect() -
Error handling bits. Flow dataFlow() .flatMapMerge { map(it) } .onEach
{ crashHandle(it) } .catch { report(it) } // <-- last in chain .collect() You're not in Kansas anymore. Pay attention! 10 11 11 https:/ /proandroiddev.com/kotlin-coroutine-job-hierarchy-finish-cancel-and-fail-2d3d42a768a9 10 https:/ /github.com/MartinDevi/Coroutines-Completion-Demo -
Kotlin Native. Flow Single-threaded coroutines.8 Single-threaded flows. Bye. 8 https:/
/github.com/Kotlin/kotlinx.coroutines/issues/462 -
Kotlin Native. Reaktive ✦ Workers-based threading ✦ Native freeze for
switching threads, i.e. almost always ✦ threadLocal operator to stop freezing ✦ In practice, not only immutable events, but also captured vars in callbacks -
Performance 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 156.474 ms/op
RxJava2ObservablePlaysScrabble avgt 90.505 ms/op RxJava2FlowablePlaysScrabble avgt 96.144 ms/op FlowPlaysScrabble avgt 84.520 ms/op ReaktivePlaysScrabble avgt 208.666 ms/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Performance 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 156.474 ms/op
RxJava2ObservablePlaysScrabble avgt 90.505 ms/op RxJava2FlowablePlaysScrabble avgt 96.144 ms/op FlowPlaysScrabble avgt 84.520 ms/op ReaktivePlaysScrabble avgt 208.666 ms/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Performance 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 156.474 ms/op
RxJava2ObservablePlaysScrabble avgt 90.505 ms/op RxJava2FlowablePlaysScrabble avgt 96.144 ms/op FlowPlaysScrabble avgt 84.520 ms/op ReaktivePlaysScrabble avgt 208.666 ms/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Performance 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 156.474 ms/op
RxJava2ObservablePlaysScrabble avgt 90.505 ms/op RxJava2FlowablePlaysScrabble avgt 96.144 ms/op FlowPlaysScrabble avgt 84.520 ms/op ReaktivePlaysScrabble avgt 208.666 ms/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Performance 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 156.474 ms/op
RxJava2ObservablePlaysScrabble avgt 90.505 ms/op RxJava2FlowablePlaysScrabble avgt 96.144 ms/op FlowPlaysScrabble avgt 84.520 ms/op FlowPlaysScrabbleFlatMap avgt 744.464 ms/op ReaktivePlaysScrabble avgt 208.666 ms/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Memory 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 254.334 MB/op
RxJava2ObservablePlaysScrabble avgt 123.316 MB/op RxJava2FlowablePlaysScrabble avgt 139.861 MB/op FlowPlaysScrabble avgt 247.987 MB/op FlowPlaysScrabbleFlatMap avgt 780.728 MB/op ReaktivePlaysScrabble avgt 351.192 MB/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Memory 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 254.334 MB/op
RxJava2ObservablePlaysScrabble avgt 123.316 MB/op RxJava2FlowablePlaysScrabble avgt 139.861 MB/op FlowPlaysScrabble avgt 247.987 MB/op FlowPlaysScrabbleFlatMap avgt 780.728 MB/op ReaktivePlaysScrabble avgt 351.192 MB/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Memory 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 254.334 MB/op
RxJava2ObservablePlaysScrabble avgt 123.316 MB/op RxJava2FlowablePlaysScrabble avgt 139.861 MB/op FlowPlaysScrabble avgt 247.987 MB/op FlowPlaysScrabbleFlatMap avgt 780.728 MB/op ReaktivePlaysScrabble avgt 351.192 MB/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Memory 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 254.334 MB/op
RxJava2ObservablePlaysScrabble avgt 123.316 MB/op RxJava2FlowablePlaysScrabble avgt 139.861 MB/op FlowPlaysScrabble avgt 247.987 MB/op FlowPlaysScrabbleFlatMap avgt 780.728 MB/op ReaktivePlaysScrabble avgt 351.192 MB/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Memory 9 Benchmark Mode Score Units RxJava1ObservablePlaysScrabble avgt 254.334 MB/op
RxJava2ObservablePlaysScrabble avgt 123.316 MB/op RxJava2FlowablePlaysScrabble avgt 139.861 MB/op FlowPlaysScrabble avgt 247.987 MB/op FlowPlaysScrabbleFlatMap avgt 780.728 MB/op ReaktivePlaysScrabble avgt 351.192 MB/op 9 https:/ /github.com/akarnokd/akarnokd-misc -
Consclusion ✦ Flow ✦ Not yet ready for MPP. Native?
✦ Not all operators we are used to are available ✦ Official support from JetBrains & Google ✦ Reaktive ✦ Real-ish Native support ✦ 1.0.x, but not really production ready ✦ Native affects performance on other platforms (JVM) - Is being FIXED ✦ Very responsive maintainers " -
Links ✦ Reaktive repo github.com/badoo/Reaktive ✦ Flow docs kotlinlang.org/docs/reference/coroutines/flow.html ✦
Reactive Scrabble Benchmark akarnokd.blogspot.com/2016/12/the- reactive-scrabble-benchmarks.html ✦ Job Hierarchy ambiguity proandroiddev.com/kotlin-coroutine-job- hierarchy-finish-cancel-and-fail-2d3d42a768a9 ✦ Sample code github.com/colriot/talk-rx-multiplatform ✦ Cover photo unsplash.com/photos/PqU63ujaIa4 -
Rx in Multiplatformland State of Reactive Streams in Kotlin Q/A
Sergey Ryabov @colriot