Reactive Programming on Android with RxJava

public
Observable
<
User
>
getUsersWithBlogs
() {
5
return
Observable
.
fromIterable
(
UserCache
.
getAllUsers
())
6
.
filter
(
user
->
user
.
blog
!=
null
&& !
user
.
blog
.
isEmpty
())
7
.
sorted
((
user1
,
user2
) ->
user1
.
name
.
compareTo
(
user2
.
name
));
8
}
The first line of the function converts the
List
returned by
UserCache.getAllUsers()
to
an
Observable
using the
Observable
creation method
.fromIterable()
. This is the first
step into making our code reactive. Now that we are operating on an
Observable
, this enables us
to perform any
Observable
operator in the RxJava toolkit:
filter()
and
sorted()
in this case.
.filter()
will filter out users that do not have blogs, and
.sorted()
will sort users that have blogs
alphabetically by name.
There are a few other points to note about this change.
First, the method signature is no longer the same. This may not be a huge deal if this method call
is only used in a few places and it’s easy to propagate the changes up to other areas of the stack;
however, if it breaks clients relying on this method, that is problematic and the method signature
should be reverted.
Second, RxJava is designed with laziness in mind (See Chapter 2:
). That is, no
long operations should be performed when there are no subscribers to the
Observable
. With this
modification that assumption is no longer true since
UserCache.getAllUsers()
is invoked even
before there are any subscribers. Whether or not the backing cache is in-memory or on disk, to stay
true to RxJava principles, this operation should be postponed until an
Observer
subscribes to it.

---

Chapter 5: Reactive Modeling on Android
60