RxJava in a nutshell

RxJava in a nutshell Alexey Bykov

Alexey Bykov * Google Developer Expert for Android * Android
Engineer @Revolut * EX: Android Academy MSK community lead * EX: Podlodka Crew & AppsConf

RxJava — complicated

Goal To make RxJava easier for you

Lifecycle

Observable.just("Hey") .subscribeOn(Schedulers.io()) .map { printThread() it.length } .observeOn(AndroidSchedulers.mainThread()) .doOnSubscribe {
printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() }

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //Ordering?

//Ordering? Observable.just("Hey") .subscribeOn(Schedulers.io()) .map { printThread() it.length } .observeOn(AndroidSchedulers.mainThread()) .doOnSubscribe
{ printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //Threading?

//1. Creation

public static <T> Observable<T> just(T item) { ObjectHelper.requireNonNull(item, "item is
null"); return RxJavaPlugins.onAssembly( new ObservableJust<T>(item) ); } Observable.just("Hey")

Observable.just("Hey") public static <T> Observable<T> just(T item) { ObjectHelper.requireNonNull(item, "item
is null"); return RxJavaPlugins.onAssembly( new ObservableJust<T>(item) ); }

subscribeOn(Schedulers.io()) public final Observable<T> subscribeOn(Scheduler scheduler) { ObjectHelper.requireNonNull(scheduler, "scheduler is
null»); return RxJavaPlugins.onAssembly( new ObservableSubscribeOn<T>(this, scheduler) ); }

Observable.just("Hey")  .subscribeOn(Schedulers.io()) .map { printThread() it.length } .observeOn(AndroidSchedulers.mainThread()) .doOnSubscribe {
printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Store reference

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Store reference Store reference

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Store reference Store reference Store reference

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Store reference Store reference Store reference Store reference

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Store reference Store reference Store reference Store reference Store reference

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Store reference Store reference Store reference Store reference Store reference Store reference

//2. Subscription

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe //1. Change thread: Computation

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe //1. Change thread: Computation Subscribe

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe //1. Change thread: Computation //2. Execute callback: Computation Subscribe

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe //1. Change thread: Computation //2. Execute callback: Computation Subscribe Subscribe

Observable.just("Hey") .subscribeOn(Schedulers.io()) .map { printThread() it.length }  .observeOn(AndroidSchedulers.mainThread()) .doOnSubscribe {
printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe //1. Change thread: Computation //2. Execute callback: Computation Subscribe Subscribe Subscribe

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe //1. Change thread: Computation //2. Execute callback: Computation Subscribe Subscribe Subscribe Subscribe

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe //1. Change thread: Computation //2. Execute callback: Computation Subscribe Subscribe Subscribe Subscribe //3. Change thread: IO

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Subscribe Subscribe //1. Change thread: Computation //2. Execute callback: Computation Subscribe Subscribe Subscribe Subscribe //3. Change thread: IO Subscribe

//3. Emission

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Emit «Hey», IO

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } Emit «Hey», IO Emit «Hey», IO

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, IO Emit «Hey», IO Emit «Hey», IO

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, IO Emit «Hey», IO Emit «Hey», IO Emit «Hey», IO

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, IO //2. Change thread, Main Emit «Hey», IO Emit «Hey», IO Emit «Hey», IO

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, IO //2. Change thread, Main Emit «Hey», IO Emit «Hey», IO Emit «Hey», IO Emit «Hey», Main

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, IO //2. Change thread, Main Emit «Hey», IO Emit «Hey», IO Emit «Hey», IO Emit «Hey», Main Emit «Hey», Main

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, IO //2. Change thread, Main Emit «Hey», IO Emit «Hey», IO Emit «Hey», IO Emit «Hey», Main Emit «Hey», Main Emit «Hey», Main

printThread() } .subscribeOn(Schedulers.computation()) .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, IO //2. Change thread, Main //3. Print thread, Main Emit «Hey», IO Emit «Hey», IO Emit «Hey», IO Emit «Hey», Main Emit «Hey», Main Emit «Hey», Main

Observable.just("Hey") … .observeOn(AndroidSchedulers.mainThread()) … .flatMap { printThread() //Own lifecycle: Creation,
Subscription, Emission Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() }

Observable.just("Hey") … .observeOn(AndroidSchedulers.mainThread()) … .flatMap { printThread() 1. Creation Observable.timer(1,
TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { printThread() } }.subscribe { printThread() }

Observable.just("Hey") … .observeOn(AndroidSchedulers.mainThread()) … .flatMap { printThread() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single())
.doOnSubscribe { printThread() } }.subscribe { printThread() }

.doOnSubscribe { printThread() } }.subscribe { printThread() } Store reference

.doOnSubscribe { printThread() } }.subscribe { printThread() } Store reference Store reference

Observable.just("Hey") … .observeOn(AndroidSchedulers.mainThread()) … .flatMap { printThread() 2. Subscription Observable.timer(1,

.doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, Main

.doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, Main //2. Change thread, Single

public static Observable<Long> timer(long delay, TimeUnit unit) { return timer(delay,
unit, Schedulers.computation() ); } Observable.timer

public static Observable<Long> timer(long delay, TimeUnit unit) { return timer(delay,
unit, Schedulers.computation() ); } public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler) { ObjectHelper.requireNonNull(unit, "unit is null"); ObjectHelper.requireNonNull(scheduler, "scheduler is null"); return RxJavaPlugins.onAssembly( new ObservableTimer(Math.max(delay, 0L), unit, scheduler)); }

.doOnSubscribe { printThread() } }.subscribe { printThread() } //1. Print thread, Main //2. Change thread, Single //3. Change thread, Computation

Observable.just("Hey") … .observeOn(AndroidSchedulers.mainThread()) … .flatMap { printThread() 3. Emission Observable.timer(1,

.doOnSubscribe { printThread() } }.subscribe { printThread() } Emit 0, Computation

.doOnSubscribe { printThread() } }.subscribe { printThread() } Emit 0, Computation Emit 0, Computation

.doOnSubscribe { printThread() } }.subscribe { //1. Print thread, Computation printThread() } Emit 0, Computation Emit 0, Computation

Lifecycle: Conclusions

Lifecycle: Conclusions //1. Creation (From builder until terminal operator reached)

Builder operators example //1. just //2. fromCallable //3. defer //4.
interval //5. delay https://reactivex.io/documentation/operators.html etc…

Terminal operators example //1. subscribe() //2. blockingGet() … https://reactivex.io/documentation/operators.html etc…

Lifecycle: Conclusions //1. Creation (until terminal operator reached) //2. Subscription
(until top(builder) operator reached)

Executable on subscription step //1. subscribeOn //2. startWith //3. doOnSubscribe
https://reactivex.io/documentation/operators.html etc…

Lifecycle: Conclusions //1. Creation (until terminal operator reached) //2. Subscription
(until top(builder) operator reached) //3. Emission

Executable on emission step //1. observeOn //2. doOnNext, doOnError, catch
//3. *map family https://reactivex.io/documentation/operators.html //4. disctinctUntilChange etc…

Opinion: only latest to the top subscribeOn will be executed
and applied

Observable.just("Hey") .subscribeOn(Schedulers.io()) .subscribeOn(Schedulers.io()) .subscribeOn(Schedulers.io()) .subscribe{ }

Observable.just("Hey") .doOnSubscribe { } .subscribeOn(Schedulers.io()) .doOnSubscribe { } .subscribeOn(Schedulers.io()) .doOnSubscribe
{ } .subscribeOn(Schedulers.io()) .subscribe { }

Observable.just("Hey") .doOnSubscribe { } .subscribeOn(Schedulers.io()) .doOnSubscribe { } .subscribeOn(Schedulers.io()) .doOnSubscribe
{ } .subscribeOn(Schedulers.io()) .subscribe { } //Thread 1 //Thread 2 //Thread1

Opinion: only latest to the top subscribeOn will be executed
and applied All subscribeOn will be executed, but latest applied

Case: Efficient Search

private val subject = PublishSubject.create() fun onTextInserted(text:String) { subject.onNext(text) }

init { } subject.debounce(300, TimeUnit.MILLISECONDS)

init { } subject.debounce(300, TimeUnit.MILLISECONDS) .switchMap { getData() }

init { } subject.debounce(300, TimeUnit.MILLISECONDS) .switchMap { getData() } .distinctUntilChanged()

init { } subject.debounce(300, TimeUnit.MILLISECONDS) .switchMap { getData() } .distinctUntilChanged()
.observeOn(AndroidSchedullers.mainThread())

init { subject.debounce(300, TimeUnit.MILLISECONDS) } .switchMap { getData() } .distinctUntilChanged()
.observeOn(AndroidSchedullers.mainThread()) .subscribeTillCleared(::setState,::processError)

Case: Shared http request

The same content

The same content PesRepository

The same content PesRepository Network Network Network

Idea: PesRepository Network Shared request

Connectable Observable

Connectable Observable //1. Doesn’t start when you executed subscribe() //2.
Starts when you executed connect()

val pes: Single<Pes> = service.getPes()

val pes: Observable<Pes> = service.getPes()

val pes: ConnectableObservable<Pes> = getFromNetwork().publish()

val pes: ConnectableObservable<Pes> = getFromNetwork().publish() pes.subscribe() pes.subscribe() pes.subscribe() // nothing
will happen

val pes: ConnectableObservable<Pes> = getFromNetwork().publish() pes.subscribe() pes.subscribe() pes.subscribe() pes.connect()

val pes: ConnectableObservable<Pes> = getFromNetwork().publish() pes.subscribe() pes.subscribe() pes.subscribe() pes.connect() Shared
request

val pes: Observable<Pes> = getFromNetwork().publish().refCount() pes.subscribe() pes.subscribe() pes.subscribe() Shared request

val pes: Observable<Pes> = getFromNetwork().share() pes.subscribe() pes.subscribe() pes.subscribe() Shared request

Case: Mediator pattern

class LogoutMediator { } private val subject = PublishSubject.create()

class LogoutMediator { } fun logoutRequired() { } subject.onNext() private
val subject = PublishSubject.create()

class LogoutMediator { } private val subject = PublishSubject.create() fun
logoutRequired() {…}

logoutRequired() {…} fun observeLogout(): Observable<Unit> = subject

logoutRequired() {…} fun observeLogout(): Observable<Unit> = subject .toSeriallised()

Case: Polling

Observable.interval(0, 1, TimeUnit.SECONDS)

Observable.interval(0, 1, TimeUnit.SECONDS) .switchMap { getData() }

Observable.interval(0, 1, TimeUnit.SECONDS) .switchMap { getData() } .observaOn(AndroidSchedullers.mainThread()) .subscribe(::processData,::processError)

Case: Testing

class Repository….

class Repository…. fun getDog() :Single<Dog> = service.getDog() .subscribeOn(Schedullers.io() .map(::toDomain())

fun test() @Test

fun test() = when(service.getDog()).thenReturn(Single.just(DogDto(…))) @Test

fun test() = when(service.getDog()).thenReturn(Single.just(DogDto(…))) repository.getDog() .test() .assertNoErrors() .assertValue(Dog(…)) @Test

fun test() = when(service.getDog()).thenReturn(Single.just(DogDto(…))) repository.getDog() .test() .assertNoErrors() .assertValue(Dog(…)) @Test It
doesn’t work ¯\_(ツ)_/¯

class Repository…. fun getDog() :Single<Dog> = service.getDog() .subscribeOn(Schedullers.io() .map(::toDomain())

• class RxTrampolineSchedulerRule : TestRule { • • override fun
apply(base: Statement, description: Description): Statement { • return object : Statement() { • @Throws(Throwable::class) • override fun evaluate() { • RxJavaPlugins.setIoSchedulerHandler { Schedulers.trampoline() } • RxJavaPlugins.setComputationSchedulerHandler { Schedulers.trampoline() } • RxJavaPlugins.setNewThreadSchedulerHandler { Schedulers.trampoline() } • RxAndroidPlugins.setInitMainThreadSchedulerHandler { Schedulers.trampoline() } • • try { • base.evaluate() • } finally { • RxJavaPlugins.reset() • RxAndroidPlugins.reset() • } • } • } • }

fun test() = when(service.getDog()).thenReturn(Single.just(DogDto(…))) repository.getDog() .test() .assertNoErrors() .assertValue(Dog(…)) @Test

fun test() = when(service.getDog()).thenReturn(Single.just(DogDto(…))) repository.getDog() .test() .assertNoErrors() .assertValue(Dog(…)) @Test val
rule = RxTrampolineSchedullerRule() @Rule @JvmField

Case: Disposing

interface Disposable { } fun dispose() fun isDisposed()

class ViewModel…. init { interact.getDog() .observeOn(MainThread()) .subscribe(::processData,::processError) }

class ViewModel…. init { disposable = interact.getDog() .observeOn(MainThread()) .subscribe(::processData,::processError) }
private lateinit var disposable:Disposable

class ViewModel…. init {…} private lateinit var disposable:Disposable fun onCleared()
{ } disposable.dispose()

class ViewModel…. init {…} private lateinit var disposable:Disposable fun onCleared()
{ } disposable.dispose() Bad practise

class ViewModel…. private val compositeDisposable = CompositeDisposable() }

class ViewModel…. init { val disposable = interact.getDog() .observeOn(MainThread()) .subscribe(::processData,::processError)
} private val compositeDisposable = CompositeDisposable() compositeDisposable.add(disposable)

class ViewModel…. init {…} fun onCleared() { } compositeDisposable.clear() private
val compositeDisposable = CompositeDisposable

We can do better :)

shorturl.at/zEJPT ViewModel extensions

class ViewModel…. init { val disposable = interact.getDog() .observeOn(MainThread()) .subscribe(::processData,::processError)
} private val compositeDisposable = CompositeDisposable() compositeDisposable.add(disposable)

class ViewModel…. init { val disposable = interact.getDog() .observeOn(MainThread()) .subscribeTillCleared(::processData,::processError)
}

Conclusion * RxJava complicated, but you can handle it *
RxJava won’t disappear soon * New project — Kotlin Coroutines Flow * You need to know it :)

RxJava in a nutshell

RxJava in a nutshell

More Decks by Alexey Bykov

Other Decks in Technology

Featured

Transcript