Rxjava meetup presentation

Guillaume Valverde
Software Developer
guillaume.valverde@futurice.com
@drevlav
A year with RXJava
September / 2016

Observable / Observer
Pattern
Observable : emits event.
Observer : listens to events and acts accordingly.

Observable: emits data called a stream
Emits 0, 1, x or an infinite amount of items

Complete

Send an error

OBSERVABLE CONTRACT
0 to N events
nothing | error | complete

Observable exemples:
• Mouse clicks
• Button Clicks
• Network request
• Network State
• Content Provider
update
• list, array
• UI State
Everything is an event

Observable.just(“rxjava”)
“rxjava”
 
Observable.just(“rxjava”) 
.subscribe();

Observable.from(…)
1 2 3
 
Integer[] ids = {1, 2, 3}; 
Observable.from(ids) 
.subscribe();

Using Retrofit
Network
Request
Response

RxView.clicks(View view)
first
click
RxView.clicks(sendButton) 
.subscribe(click -> { 
do something… 
})
Second
click
Third
click

who is listening?
The subscriber

who is listening?
The subscriber
 
Integer[] ids = {1, 2, 3}; 
.subscribe();

Subscriber:
Observer & subscription
public abstract class
Subscriber<T> implements Observer<T>, Subscription {
…
}

Subscriber : Observer & Subscription
public interface Observer<T> { 
 
void onCompleted(); 
 
void onError(Throwable e); 
 
void onNext(T t); 
 
}
public interface Subscription { 
 
void unsubscribe(); 
 
boolean isUnsubscribed(); 
 
}

Observable / Subscriber (Observer & Subscription)
 
String[] ids = {"1", "2", "3"}; 
Subscription subscription =
.subscribe(id -> Log.v(TAG, id), 
error -> Log.e(TAG, "error: " + error.getMessage()), 
() -> Log.v(TAG, "complete"));

Stream on steroids
operators
Composition

Map
RXJava is Awesome
.map(word -> word.length())
6 2 7
String[] ids = {“RXJava”, “is”, “Awesome”}; 
Observable.from(ids)

FlatMap
1 2 3
.Flatmap ( )xxx
1
1

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2
3
3

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2
3
3
.flatten

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2
3
3
.flatten
1

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2
3
3
.flatten
1 2

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2
3
3
.flatten
1 2 2

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2
3
3
.flatten
1 2 2 1

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2
3
3
.flatten
1 2 2 1 3

FlatMap
1 2 3
.Flatmap ( )xxx
1
1
2
2
3
3
.flatten
1 2 2 1 3 3

id1 id2 id3
.flatMap(id -> fetchArticle())
Article1 Article2 Article3
FlatMap
List ids …

Compose with
Observables
Retrieve a list of repositories
• more than 3 letters
• cancel previous search when new one
• make a search when the user is done typing

Compose with Observables
 
RxTextView.textChanges(editText) 
.observeOn(Schedulers.io()) 
.debounce(500, TimeUnit.MILLISECONDS) 
.filter(charSequence -> charSequence.length() > 3) 
.map(CharSequence::toString) 
.switchMap(searchString -> networkManager.search(searchString)) 
.observeOn(AndroidSchedulers.mainThread()) 
.subscribe(list -> searchRecyclerAdapter.refreshListRepo(list), 
error -> Logger.logOnNextError(TAG));

Type RxJava
RxTextView.textChanges(editText)

Type RxJava
R Rx RxJ RxJa RxJav RxJava

Type RxJava
.observeOn(Schedulers.io())

Type RxJava

Type RxJava
.debounce(500, TimeUnit.MILLISECONDS)

Type RxJava
RxJ RxJavaR

Type RxJava
.filter(charSequence -> charSequence.length() >= 3)
RxJ RxJavaR

Type RxJava
RxJ RxJava
.filter(charSequence -> charSequence.length() >= 3)
RxJ RxJavaR

RxJ RxJava
.map(CharSequence::toString)

RxJ RxJava
.switchMap(searchString -> networkManager.search(searchString))

RxJ RxJava
List<R
epo>

RxJ RxJava
List<R
epo>
List<R
epo>

RxJ RxJava
List<R
epo>
List<Repo>
List<R
epo>

 
List<Repo>

 
List<Repo>
.observeOn(AndroidSchedulers.mainThread())

 
List<Repo>
List<Repo>

RxJ RxJava
RxJ RxJava
List<Repo>
List<Repo>
R

RXjava is synchronous
by default

by default
for(String word: sentence) { 
Log.v(TAG, word); 
}

by default
Same as
}

by default
Same as
}
Observable.from(sentence) 
.subscribe(word -> Log.v(TAG, word));

THREADING
.flatMap(id -> fetchArticle()) 
.subscribeOn(Schedulers.computation()) 
.subscribe(article -> actOnArticle(article));

ObserveOn / SubscribeOn
.subscribeOn(… newThread)
.observeOn(… mainThread)
.subscribe(…)

.subscribe(…) CurrentThread

.subscribe(…)
Change
Thread,
New Thread

.subscribe(…)
emit ids

.subscribe(…)
emit an Article

.subscribe(…) act on Article

THREADING
SubscribeOn / ObserveOn
• Only 1 SubscribeOn effective.
• Multiple ObserveOn can work.

Organise your code
Architecture / View Model / Separation of
concern

business Logic
Return Observable
Input :
Source Observable
.subscribe()

Unit
testing
Integration
testing
Acceptance / smoke
testing

ViewView Model
Architecture
Hold the
business logic
For the View
display ui
according to state of the
data
Data Layer
Store
Store
Binding
Hold the logic for data
emits Pojos

ViewView Model
Architecture
Hold the
business logic
For the View
display ui
according to state of the
data
Data Layer
Store
Store
Binding
Hold the logic for data
emits Pojos
update
trigger

.switchMap(word -> dataLayer.fetchListRepo(word)) 
 

Input :
Source Observable
 
dataLayer
UI
View
dependencies:

ViewModel
Input :
Source Observable
 
dataLayer
UI
View
dependencies:

ViewModel
Input :
Source Observable
.subscribe(…)
 
dataLayer
UI
View
dependencies:

public class ViewModel { 
 
private Observable<CharSequence> charSequenceObservable; 
private DataLayer dataLayer; 
 
ViewModel(Observable<CharSequence> charSequenceObservable,
DataLayer dataLayer) { 
this.charSequenceObservable = charSequenceObservable; 
this.dataLayer = dataLayer; 
} 
 
Observable<List<GitHubRepository>> getListObservable() { 
return charSequenceObservable 
.switchMap(word -> dataLayer.search(word)); 
} 
}

Rxjava meetup presentation

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (14)

Similar to Rxjava meetup presentation

Similar to Rxjava meetup presentation (20)

Recently uploaded

Recently uploaded (20)

Rxjava meetup presentation