Reactive programming on Android

Reactive programming on
Android
Tomáš Kypta

What’s reactive programming?
reactive programming or functional reactive
programming (FRP)

What’s reactive programming?
functional
– lambdas
– closures
– pure
– composable
reactive
– data flow
– asynchronous
– values
– events
– push

Reactive?
• observer pattern

Typical App
Event Source
Views Network DB Other
Listener Listener Listener Listener
logic logic logic logic
State

Views Network DB
Transformation
Reactive
Event Source
Other
Observable Observable Observable Observable
Observer Observer

Reactive
• abstract away from concerns about
– low-level threading
– side effects
– synchronization
– encapsulation
– resource management

Java 8
Observable.toObservable(“a”, “b”, “c”)
.take(2)
.subscribe((arg) -> {
System.out.println(arg);
});
Reactive Code

Reactive on Android
• evading callback hell
• How to execute heavy tasks on
background threads?
• And deliver results on the main (UI)
thread?

Handler handler = new Handler();
new Thread(){
@Override
public void run() {
final String result = somethingDemanding();
handler.post(new Runnable() {
@Override
public void run() {
showResult(result);
}
});
}
}.start();
Thread + Handler

Thread + Handler
• simple
• difficult to deliver on the main thread
• broken data flow

new AsyncTask<Void, Integer, String>(){
@Override
protected String doInBackground(Void...
params) {
return somethingDemanding();
}
@Override
protected void onPostExecute(String s) {
showResult(s);
}
}.execute();
AsyncTask

AsyncTask
• deals with the main thread
• error-prone
• difficult error propagation
• difficult to bound to activity/fragment
lifecycle
• difficult composition

class MyFragment extends Fragment implements
LoaderManager.LoaderCallbacks<String> {
@Override public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getLoaderManager().initLoader(42, null, this);
}
@Override public Loader<String> onCreateLoader(int id, Bundle args) {
return new AsyncTaskLoader<String>(getActivity()) {
@Override public String loadInBackground() {
return doHeavyTask();
}
};
}
@Override public void onLoadFinished(Loader<String> loader, String data) {
showResult(data);
}
@Override public void onLoaderReset(Loader<String> loader) {}
}
Loaders

Loaders
• boilerplate
• good for cursors
• deals with activity/fragment lifecycle
• difficult composition
• difficult to adjust logic

Async on Android
• many other async libraries
– some are better
– some are worse

RxJava
• Java VM implementation of Reactive
Extensions
• a library for composing flows and
sequences of asynchronous data
• open-source
• https://github.com/ReactiveX/RxJava
• by Netflix

RxJava
• DSL for creating computation flows from
async sources
• flows called Observables
• push semantics of Observables

Future
proxy or wrapper around an object that is not
yet there
future.get()
future.isDone()
• non-trivial complexity when nested
• difficult to compose conditional
asynchronous execution flows

Iterable vs. Observable
// Iterable<String>
getData()
.skip(10)
.take(5)
.map({s ->
return s + “1”})
.forEach({
println it
});
// Observable<String>
getData()
.skip(10)
.take(5)
.map({s ->
return s + “1”})
.subscribe({
println it
});

single items multiple items
synchronous T getData() Iterable<T> getData()
asynchronous Future<T> getData() Observable<T> getData()

event Iterable (pull) Observable (push)
retrieve data T next() onNext(T)
discover error throws Exception onError(Exception)
complete !hasNext() onCompleted()

Observable
Calling Thread
public Observable<String> getData();
Callback Thread
synchronous on calling thread

Observable
Calling Thread
Callback Thread
Thread Pool
asynchronous on a separate thread

Observable
Calling Thread
Callback Threads
Thread Pool
asynchronous on multiple threads

Observable
• not biased toward some particular source
of asynchronicity
• the implementation chooses if the code will
be blocking or non-blocking

public interface Observer <T> {
void onCompleted();
void onError(Throwable throwable);
void onNext(T t);
}
Observable

public Observable<String> getStrings() {
return Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
try {
subscriber.onNext("Hello");
subscriber.onNext("World");
subscriber.onCompleted();
} catch (Exception ex) {
subscriber.onError(ex);
}
}
});
}
Observable

Observable<String> strings = getStrings();
strings.subscribe(
new Observer<String>() {
@Override
public void onCompleted() {
Log.d("rx", "no more data");
}
@Override
public void onError(Throwable throwable) {
Log.e(“rx”, “error”, throwable);
}
@Override
public void onNext(String s) {
showResult(s);
}
});
Observer

Observable<String> strings = getStrings();
Subscription subsctiption = strings.subscribe(
new Observer<String>() {
@Override
public void onCompleted() {
Log.d("rx", "no more data");
}
@Override
public void onError(Throwable throwable) {
Log.e(“rx”, “error”, throwable);
}
@Override
public void onNext(String s) {
showResult(s);
}
});
Observer

Subscription
Subscription subsctiption;
subscription.unsubscribe();
subscription.isUnsubscribed();

RxAndroid
Android specific things for Rx
• Scheduler
• reliable and thread-safe with regarding
Fragment/Activity life-cycle
• reactive components for Android use cases
and UI

RxAndroid
• https://github.com/ReactiveX/RxAndroid
• 'io.reactivex:rxandroid:0.23.0'
• formerly rxjava-android

Image Loading
Observable<Bitmap> imageObservable =
Observable.create(observer -> {
return downloadBitmap();
});
imageObservable
.subscribe(image -> loadToImageView(image));

Image Loading
imageObservable
.subscribeOn(Schedulers.newThread())

Image Loading
imageObservable
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())

public void onDestroy() {
super.onDestroy();
subscription.unsubscribe();
}
Lifecycle & Memory Leaks

Fragment/Activity Lifecycle
ContentObservable
.bindFragment(fragment, observable);
ContentObservable
.bindActivity(activity, observable);

Broadcast Receiver
Observable<Intent> observable =
ContentObservable
.fromBroadcast(context, intentFilter);
Observable<Intent> observable =
ContentObservable
.fromLocalBroadcast(context, intentFilter);

Views
Observable<OnClickEvent> observable =
ViewObservable.clicks(view);
ViewObservable
.bindView(view, observable);

Creating Observables
• manually from scratch
create()

• convert existing data structure into an
Observable
from()
– Iterable, Future, Array
repeat()
– emit source Observable repeatedly

Observable
timer()
– emits a single item after a given time

Observable
empty()
– emits nothing and completes
error()
– emits nothing and signals an error
never()
– emits nothing at all

Obervables are composable
transform - map, flatMap, reduce, scan
filter - take, skip, sample, filter
combine - concat, merge, zip, cache
concurrency - observeOn, subcribeOn
error handling - onErrorReturn

Transforming Observables
map()
– apply a function to each item

flatMap()
– transform items into Observables and
flatten

scan()
– apply a function to each item
sequentially and emit each successive
value

groupBy()
– divide into a set of Observables

buffer()
– periodically gather items into bundles
and emits these bundles

Filtering Observable
filter()
– filter emitted items

take()
– emit only first n items

timeout()
– emit items, but issue an exception if
nothing emitted in a timespan

distinct()
– suppress duplicate items

takeLastBuffer()
first()
elementAt()
– emit only n-th element
ignoreElements()
– pass only error or completed

Combining Observables
merge()
– combine multiple Observables

Combining Observables
zip()
– combine multiple Observables via a
function, emit results of the function

Error Handling
recovering from onError()
onErrorResumeNext()
– emit a sequence if error happens

Error Handling
onErrorReturn()
– emit an item if error happens

Error Handling
retry()
– resubscribe to a source

Support for RxJava in other
libraries

Retrofit
@GET("/user/{id}/photo")
Observable<Photo> getUserPhoto(@Path("id") int id);

private Object simpleMethod() { ... }
public Observable<Object> newMethod() {
return Observable.just(simpleMethod());
}
Plain old library

private Object simpleMethod() { ... }
public Observable<Object> newMethod() {
return Observable.defer(() ->
Observable.just(simpleMethod())
);
}
Plain old library

Java 8 & Android
No lambdas on Android
– use different language on Android
– or rather not

Retrolambda
transforms Java 8 compiled bytecode for
older JVM
• gradle-retrolambda
– https://github.com/evant/gradle-retrolambda
– 'me.tatarka:gradle-retrolambda:2.4.1'
• retrolambda
– https://github.com/orfjackal/retrolambda

strings.map(new Func1<String, Integer>() {
@Override
public Integer call(String s) {
return s.length();
}
});
Without Retrolambda

strings.map(
(String s) -> { return s.length(); }
);
With Retrolambda

Problems
• RxAndroid APIs not yet stabilized even
though RxJava hitting version 1.0
– RxAndroid version 0.23
• backpressure

Reactive programming on Android

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to Reactive programming on Android (20)

More from Tomáš Kypta (20)

Recently uploaded (20)

Reactive programming on Android