Reactive Programming on Android with RxJava

The Lazy Approach
As mentioned earlier, RxJava was designed with laziness in mind. That is, long-running operations
should be delayed as much as possible until
.subscribe()
is invoked on an
Observable
. To make our
solution lazy we can make use of the
Observable
creation methods
.fromCallable()
or
.defer()
.
.defer()
takes in an
ObservableSource
which is basically a factory that returns an
Observ-
able
whenever the outer
Observable
is subscribed to. In our case, we want to return
Observ-
able.fromItereable(User.getAllUsers())
whenever an
Observer
subscribes.
1
/**
2
* @return a list of users with blogs
3
*/
4
public
Observable
<
User
>
getUsersWithBlogs
() {
5
return
Observable
.
defer
(() ->
6
Observable
.
fromIterable
(
UserCache
.
getAllUsers
())
7
).
filter
(
user
->
user
.
blog
!=
null
&& !
user
.
blog
.
isEmpty
())
8
.
sorted
((
user1
,
user2
) ->
user1
.
name
.
compareTo
(
user2
.
name
));
9
}
Now that the long running operation is wrapped in a
.defer()
, we have full control as to what
thread this should run on simply by specifying the appropriate
Scheduler
in
.subscribeOn()
and
.observeOn()
.

---

Chapter 5: Reactive Modeling on Android
62
1
/**
2
* @return a list of users with blogs
3
*/
4
public
Observable
<
User
>
getUsersWithBlogs
() {
5
return
Observable
.
defer
(() ->
6
Observable
.
fromIterable
(
UserCache
.
getAllUsers
())
7
).
subscribeOn
(
Schedulers
.
io
())
8
.
filter
(
user
->
user
.
blog
!=
null
&& !
user
.
blog
.
isEmpty
())
9
.
sorted
((
user1
,
user2
) ->
user1
.
name
.
compareTo
(
user2
.
name
))
10
.
observeOn
(
AndroidSchedulers
.
mainThread
());
11
}
With this change, all subscriptions should now occur on a thread provided by
Schedulers.io()
and
the resulting emission will be propagated to the Android main thread. Our code is now fully reactive
and subscription should only occur at the moment the data is needed.
Reactive Everything
From the previous examples, we have seen that we can wrap any object in an
Observable
and jump
between non-reactive and reactive states using
.blockingX()
operators. In addition, we can delay
execution of an operation by wrapping it in a
.fromCallable()
or
.defer() Observable
creation
method. Using these constructs, we can start converting areas of an Android app to be reactive.
Long Operations
A good place to start using RxJava is whenever you have a process that takes a while to compute—
network calls, disk reads and writes, bitmap processing, etc. The following example illustrates a
simple function that will write text to the file system.
1
/**
2
* Writes {@code text} to the file system.
3
*
4
* @param context a Context
5
* @param filename the name of the File
6
* @param text the String of text to write
7
* @return true if the text was successfully written, otherwise, false
8
*/
9