Reactive Programming on Android with RxJava

new
Observer
<
String
>() {
6
@Override
7
public
void
onSubscribe
(
Disposable d
) {
8
}
9
10
@Override
11
public
void
onNext
(
String value
) {
12
Log
.
d
(
TAG
,
"onNext(): "
+
value
);
13
}
14
15
@Override
16
public
void
onError
(
Throwable e
) {
17
}
18
19
@Override
20
public
void
onComplete
() {
21
Log
.
d
(
TAG
,
"onComplete()"
);
22
}
23
});
24
Log
.
d
(
TAG
,
"After subscribing."
);
The above code snippet will display in the console:
1
Creating Observable
.
2
onNext
() -
test
3
onComplete
()
4
After subscribing
.
The resulting order of print statements is observed since RxJava does not specifically impose
asynchronous behavior. It is not opinionated about where the asychronicity originates unless it
is otherwise specified.

---

Chapter 2: RxJava Core Components
18
RxJava is synchronous by default. It is not opinionated about where asynchronicity
originates; it must be explicitly specified.
As you might guess, synchronous behavior may not be desired, and in many real-world cases, we
would want the underlying
Observable
to operate on a separate thread from the calling thread. The
power of RxJava lies in dealing with asynchronous streams, and we will look at how to do multi-
threading in RxJava in
. For now though, it is important to understand
that just because an
Observer
receives items via
push
does not mean that any sort of concurrency
is imposed.
RxJava also supports
pulling
from an
Observable
. Although this is not idiomatic RxJava, it was
included primarily for interoperability with codebases that aren’t 100% fully adapted to be reactive.
We will look at this more in