Reactive Programming on Android with RxJava

return true
;
24
}).
subscribeOn
(
Schedulers
.
io
());
25
}
Using
.fromCallable()
, writing the text to file is deferred up until subscription time. Since
exceptions are first-class objects in RxJava, one other benefit of our change is that we no longer
need to wrap the operation in a try/catch, the exception will simply be propagated downstream
rather than being swallowed. This allows the caller to handle the exception in a granular way (i.e.
show an error to the user depending on what exception was thrown).
One other optimization we can do is return a
Completable
rather than an
Observable
. A
Com-
pletable
is a special type of
Observable
–similar to a
Single
–that simply indicates if a computation
succeeded via
.onCompleted()
, or failed via
.onError()
. In this example, returning a
Completable
makes more sense since it seems superfluous to return a single
true
in an
Observable
stream.
1
/**
2
* Writes {@code text} to the filesystem.
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 A Completable
8
*/
9
public
Completable
writeTextToFile
(
10
Context context
,
11
String filename
,
12
String text
13
) {
14
return
Completable
.
fromAction
(() -> {
15
FileOutputStream outputStream
;
16
outputStream
=
context
.
openFileOutput
(
17
filename
,
18
Context
.
MODE_PRIVATE
19
);
20
outputStream
.
write
(
text
.
getBytes
());
21
outputStream
.
close
();
22
}).
subscribeOn
(
Schedulers
.
io
());
23
}

---

Chapter 5: Reactive Modeling on Android
65
To complete the operation, we use the
.fromAction()
operation of a
Completable
since the previous
return value of
true
is no longer needed.
Completable, Single, and Maybe
So far, the
Observable
class has been our focus for enabling reactive programming with RxJava.
However, RxJava also offers the following alternative base reactive types:
Single
In our previous example in
Leaving the Reactive World
, we have looked at another base reactive
type called a
Single
. As mentioned, a
Single
is a special type of
Observable
that only emits a
single
item rather than a stream of items. As a consequence, an observer to a
Single
, a
SingleObserver
,
has a different signature and will only receive the following events:
•
.onSubscribe()
: invoked on subscription and a
Disposable
object is passed along which can
be used to
unsubscribe
from the
Single
•
.onSuccess()
: invoked when the
Single
has emitted an item
•
.onError()
: invoked when the
Single
has encountered an error
1
public interface
SingleObserver
<
T
> {
2
3
void
onSubscribe
(
Disposable d
);
4
5