RxJava in Baby Steps

A presentation at KotlinConf in November 2017 in San Francisco, CA, USA by Annyce Davis

-36.34543, 3.23445
-36.24543, 3.23425
GPS Updates Time

-36.34543, 3.23445
-36.24543, 3.23425
-35.34543, 3.13445 GPS Updates Time

Which of the following is an asynchronous data stream? A: click events B: database access C: server response D: all of the above

A: click events B: database access C: server response D: all of the above Which of the following is an asynchronous data stream?

Data Transformation Observable.just( 5 , 6 , 7 ) .map { ";-) " . repeat ( it ) }
.subscribe { println ( it ) }

chaining Observable.just( 5 , 6 , 7 ) .map { ";-) " . repeat ( it ) }
.filter { it . length < 24 }
.subscribe { println ( it ) }

RxJava i s. . . ? A: the silver bullet B: simply magic C: pure voodoo D: a library

listOf ( 5 , 6 , 7 ) . map { it * 5 }
. filter { it
25 }
kotlin collections

listOf ( 5 , 6 , 7 ) . map { it * 5 }
. filter { it
25 }
kotlin collections 5 6 7

listOf ( 5 , 6 , 7 ) . map { it * 5 }
. filter { it
25 }
kotlin collections 5 6 7 map 25 30 35

listOf ( 5 , 6 , 7 ) . map { it * 5 }
. filter { it
25 }
kotlin collections 5 6 7 map 25 30 35 filter 30 35

listOf ( 5 , 6 , 7 ) . asSequence () . map { it * 5 }
. filter { it
25 }
. toList () kotlin sequences

kotlin sequences listOf ( 5 , 6 , 7 ) . asSequence () . map { it * 5 }
. filter { it
25 }
. toList () 5 6 7

5 6 7 map filter kotlin sequences 25 listOf ( 5 , 6 , 7 ) . asSequence () . map { it * 5 }
. filter { it
25 }
. toList ()

5 6 7 map filter kotlin sequences 25 30 30 listOf ( 5 , 6 , 7 ) . asSequence () . map { it * 5 }
. filter { it
25 }
. toList ()

5 6 7 map filter kotlin sequences 25 30 35 30 35 listOf ( 5 , 6 , 7 ) . asSequence () . map { it * 5 }
. filter { it
25 }
. toList ()

RxJava numbers
`.`
map { it * 5 }
. filter { it
25 }
. subscribe ()

RxJava numbers
`.`
map { it * 5 }
. filter { it
25 }
. subscribe () 5 25 map filter

RxJava numbers
`.`
map { it * 5 }
. filter { it
25 }
. subscribe () 5 6 map filter 25 30 30

RxJava numbers
`.`
map { it * 5 }
. filter { it
25 }
. subscribe () 5 6 map filter 25 30 30 35 7 35 35

Observable.just( 5 , 6 , 7 )
.map {
";-) " . repeat ( it ) }
.subscribe {
println ( it ) }

Observable.just( 5 , 6 , 7 )
`.`
subscribeOn( Schedulers.io ())
.map {
";-) " . repeat ( it ) }
.subscribe {
println ( it ) }

The Basics operators observable observer

Observable.create<Int> { subscriber
-> }

Observable.create<Int> { subscriber
-> }
Observable.just( item1 , item2 , item3 )

Observable.create<Int> { subscriber
-> }
Observable.just( item1 , item2 , item3 ) Observable .interval( 2 , TimeUnit. SECONDS )

Observable.create<Int> { subscriber ->
Logger.log( "create" ) Logger.log( "complete" ) } Logger.log( "done" )

Observable.create<Int> { subscriber ->
Logger.log( "create" ) subscriber.onNext( 5 ) subscriber.onNext( 6 ) subscriber.onNext( 7 )
Logger.log( "complete" )
} Logger.log( "done" )

Observable.create<Int> { subscriber ->
Logger.log( "create" ) subscriber.onNext(5) subscriber.onNext(6) subscriber.onNext(7) subscriber.onComplete() Logger.log( "complete" ) } Logger.log( "done" )

A: emit items B: be cold C: be hot D: all of the above Observables ca n. . .

interface Observer<T
{
fun onError(e: Throwable)
fun onComplete()
fun onNext(t: T )
fun onSubscribe(d: Disposable) }

observer’s lifecycle onNext Normal flow onSubscribe

observer’s lifecycle onComplete Normal flow onSubscribe onNext

observer’s lifecycle onComplete onError Normal flow onSubscribe onNext

val observer = object : Observer<Int> {
override fun onError(e: Throwable) { Logger.log(e) }
override fun onComplete() { Logger.log( "on complete" ) }
override fun onNext(t: Int) { Logger.log( "next: $ t " ) }
override fun onSubscribe(d: Disposable) { Logger.log( "on subscribe" ) } }

interface Consumer<T
{
fun accept(t: T ) }

val consumer = object : Consumer<Int> {
override fun accept(t: Int) { Logger.log( "next: $ t " ) }
}

val consumer = Consumer <Int> { t -> Logger.log( "next: $ t " ) } obs.subscribe(consumer) consumer

obs.subscribe( Consumer <Int> { t -> Logger.log( "next: $ t " ) } ) consumer

obs.subscribe( { t -> Logger.log( "next: $ t " ) } ) consumer

obs.subscribe { Logger.log( "next: $it " ) }
consumer

A: have a lifecycle
B: always complete
C: Never Error
D: all of the above Observ ers. . .

Observ ers. . . A: have a lifecycle
B: always complete
C: Never Error
D: all of the above

Operator: map() Observable.just(5, 6, 7) .map { ";-) " . repeat ( it ) }
.subscribe { println ( it ) }

Operator: map() Observable.just(5, 6, 7) .map( object : Function<Int, String> {
override fun apply(t: Int): String {
return ";-) " . repeat (t) } })
`.subscribe`
{ println ( it ) }

`.map(`
object : Function<Int, String> {
override fun apply(t: Int): String {
return ";-) " . repeat (t) } }) .map { ";-) " . repeat ( it ) }

what’s the output? Observable.just( 1, 2, 3 ) .map { it * 2
}
.subscribe { println ( it ) }

A: 1, 2, 3
B: a, b, c
C: 2, 4, 6
D: 6, 2, 4 Observable.just( 1, 2, 3 ) .map { it * 2
}
.subscribe { println ( it ) } what’s the output?

Observable.just(1, 2, 3 ) .map { it * 2
}
.subscribe { println ( it ) } A: 1, 2, 3
B: a, b, c
C: 2, 4, 6
D: 6, 2, 4 what’s the output?

what’s the output? Observable.just( 1, 2, 3 ) .map { it * 2
}
`.filter`
{ it < 6
}
.subscribe { println ( it ) }

A: 2, 3, 1
B: 2, 4 C: 1, 2, 3
D: 6, 4 what’s the output? Observable.just( 1, 2, 3 ) .map { it * 2
}
`.filter`
{ it < 6
}
.subscribe { println ( it ) }

what’s the output? Observable.just(1, 2, 3 ) .map { it * 2
}
`.filter`
{ it < 6
}
.subscribe { println ( it ) } A: 2, 3, 1
B: 2, 4 C: 1, 2, 3
D: 6, 4

Operator: flatmap() via reactivex.io item

Operator: flatmap() via reactivex.io item observable

Operator: flatmap() Observable.just( ,
) .flatMap( { Observable.just( ) } )
.subscribe { println ( it ) } :-( :-(

Operator: flatmap() val users // Observable<User>

Operator: flatmap() val users // Observable<User>
val posts: Observable<Post>

Operator: flatmap() val users // Observable<User> val posts: Observable<Post> posts = users.flatMap { getUsersPosts( it . id ) }

Operator: flatmap() val users // Observable<User> val posts: Observable<Post> posts = users.flatMap { getUsersPosts( it . id ) }
posts.subscribe { println ( it ) }

Flowable Maybe backpressure Disposable Single completable

like functional programing? Process items asynchronously?
compose data? handle errors gracefully? should you use rxjava?

should you use rxjava? like functional programing? Process items asynchronously?
compose data? handle errors gracefully?

• Reactive Programming on Android with RxJava ( http://amzn.to/2yOAkxn )
• Reactive Programming with RxJava ( http://amzn.to/2zQtqb5 )
• RxJava Playlist (https://goo.gl/9fw1Zv)
• Learning RxJava for Android Devs (https://goo.gl/VWxFLK )
• RxJava Video Course ( https://caster.io/courses/rxjava ) resources

slide design: @lauraemilyillustration font: Elliot 6, fontSquirrel.com

Annyce Davis
@annyce

1 / 159

Reactive Programming with RxJava has widely been adopted by both backend services and Android applications alike. Yet, the steep learning curve leaves many developers hesitant about adding it to their own Software tool belt. I was one such developer.

Over the past two years, I’ve watched countless videos, read numerous blog posts and attended several conference talks on the subject. Yet, I often left each experience feeling only slightly more knowledgeable, but not quite empowered to start using RxJava in my apps. That’s not going to happen today!

In this talk, we’re going to cover the bare minimum concepts you need to grok, in order to start using RxJava today. In particular, we’re going to focus on:

The 3 O’s: Observable, Observer and Operator The most common Operators: map(), flatMap(), and filter() Understanding those Marble Diagrams How Kotlin helps to simplify the code

Reactive Programming is not going away any time soon. It’s a powerful way to create asynchronous, event-based applications. It allows developers the ability to craft applications that can easily combine multiple network calls, gracefully handle failures, all while providing a snappy user experience. I want everyone to feel comfortable with the basic concepts of RxJava. Today can be your first step...

Video

Resources

The following resources were mentioned during the presentation or are useful additional information.

Talk: RxJava in Baby Steps

Links to various resources mentioned in the talk.

RxJava in Baby Steps

Link for this presentation:

HTML code for embedding:

Share on social media:

Video

Resources

Talk: RxJava in Baby Steps