Reactive Programming on Android with RxJava

Marble diagram of .window()
Why might you want a stream of
Observable
s instead of lists? It’s helpful to think of this difference
in terms of the difference between
.map()
and
.flatMap()
as we’ve seen in Chapter 3 (See
Chapter 3:
.flatMap()
). With a stream of
Observable
s, we can further chain operators and even add concurrency
(See
Chapter 4: Concurrency with .flatMap()
).

---

Chapter 7: Error Handling
In Java, when an error occurs in the normal flow of a program, an
Exception
is thrown. A try/catch
statement can then be used to recover from the Exception and perform the appropriate fallback
behavior (i.e. ignore the error and continue, retry the operation, display an error message to the user
etc.). Most Exceptions that are handled in this manner are
checked
exceptions, that is, the thrown
Exception needs to be declared and explicitly handled for our code to compile.
Unchecked
exceptions
however, are harder to catch and if not handled, can cause our application to crash. Oftentimes, this
is not the behavior that we want since we want apps to be perform well despite these edge cases.
In RxJava, errors are treated slightly different. Rather than being seen as
exceptions
from the normal
flow of a program, errors are considered to be a part of the normal flow of the program and thus
should be accounted for when dealing with a given stream. In this chapter, we will look at different
ways of handling errors in an
Observable
to help create resilient applications.
Errors Along the Chain
As we’ve seen earlier, one of the events an
Observer
can receive is the
.onError(Throwable)
event.
.onError()
is considered a terminal such that once triggered, the
Observable
will no longer emit
any other event. There are several ways to invoke the
.onError()
notification, some are explicit
such as invoking the
.onError()
on an
Emitter
:
1
Observable
<
Integer
>
observable
=
Observable
.
create
(
emitter
-> {
2
emitter
.
onError
(
new
Exception
(
"An error occurred."
));
3
});
4
observable
.
subscribe
(
i
-> {
5
},
throwable
-> {
6
Log
.
e
(
TAG
,
"onError(): "
+
throwable
.
getMessage
());
7
});
Or by returning an
Observable.error()
wherever an
Observable
is expected such as in the
.flatMap()
operator:

---

Chapter 7: Error Handling
92
1
Observable
<
Integer
>
observable
=
2
Observable
.
range
(0, 10).
flatMap
(
i
-> {
3