Reactive Programming on Android with RxJava

void
onSuccess
(
T value
);
6
7
void
onError
(
Throwable e
);
8
}
Completable
As we’ve seen in the previous example of writing text to the file system, a
Completable
is another
base reactive type that notifies an observer whether or not an operation succeeds. It does not emit
an item, it simply tells the observer if the operation passes or fails. An observer to a
Completable
, a
CompletableObserver
, has the following events:
•
.onSubscribe()
: invoked on subscription and a
Disposable
object is passed along which can
be used to
unsubscribe
from the
Completable
•
.onComplete()
: invoked when the
Completable
completes
•
.onError()
: invoked when the
Completable
has encountered an error

---

Chapter 5: Reactive Modeling on Android
66
1
public interface
CompletableObserver
<
T
> {
2
3
void
onSubscribe
(
Disposable d
);
4
5
void
onComplete
();
6
7
void
onError
(
Throwable e
);
8
}
Maybe
A
Maybe
can be thought of as a mix of a
Single
and a
Completable
. It is like a
Single
in that 1 item
may be
emitted, or like a
Completable
in that 0 items
may be
emitted. Its observer, a
MaybeObserver
,
has the following events:
•
.onSubscribe()
: invoked on subscription and a
Disposable
object is passed along which can
be used to
unsubscribe
from the
Maybe
•
.onComplete()
: invoked when the
Maybe
completes. This method is invoked when the
Maybe
does not emit an item
•
.onSuccess(T value)
: invoked when the
Maybe
emits a single item
•
.onError()
: invoked when the
Completable
has encountered an error
1
public interface
MaybeObserver
<
T
> {
2
3
void
onSubscribe
(
Disposable d
);
4
5
void
onSuccess
(
T value
);
6
7
void
onComplete
();
8
9
void
onError
(
Throwable e
);
10
}
Since
Single
,
Maybe
and
Completable
offer a subset of capabilities compared to an
Observable
, as
you might imagine, the operators that can be performed on them are also limited. For example, the
.toList()
operator is not available on a
Single
or a
.reduce()
operator on a
Completable
.
Collectively, these alternative base reactive types allow you to be more specific in the type system.
While it is perfectly valid to use an
Observable
that only emits a single item or an
Observable
that
only invokes a terminal event, it is preferred to be as specific as possible as it is more expressive and
it informs the caller about the expected behavior of the underlying computation.

---

Chapter 5: Reactive Modeling on Android
67
If another type is required, however, say when using the operator
.zip()
with a
Single
and with
an
Observable
, it is possible to convert between the two types through transformational methods
(e.g.
Single
,
Maybe
and
Completable
have the
.toObservable()
method which converts the type
to an
Observable
). Conversely, an
Observable
can may be converted to another base reactive type
depending on the operator. For example, as we’ve seen in a previous example invoking
.toList()
on an
Observable
returns a
Single
.