Gain insights into RxJava's principles, explore its integration into Android, and discover why it’s the leading reactive library for enhanced app development.

Reactive Programming on Android with RxJava_468 x 60 copy 2.png

tarball.tar.gz

RxJava

Since its inception in 2012, RxJava has slowly gained in popularity for enabling reactive programming on Android. It is now deemed as the go-to and leading reactive library. Many companies have adopted the reactive way of programming, including Google, with its release of Android Architecture Components, which has many reactive elements in its design.

In this course, you will learn the fundamental principles of RxJava which will serve as a foundation for experienced Android developers who are new to the library and want to start integrating it into their apps.

Reactive Programming with RxJava


An `Observable` can emit any number of items. As mentioned, to receive or listen to these emitted items, an `Observer` needs to subscribe to the `Observable`. The `.subscribe()` method is defined by the `ObservableSource` interface, which is implemented by `Observable`.

public interface ObservableSource<T> {
    void subscribe(Observer<? super T> observer);
}

Once the `Observable` and `Observer` have been paired via the `.subscribe()` method, the `Observer` receives the following events through its defined methods:

* The `.onSubscribe()` method is called along with a `Disposable` object that may be used to unsubscribe from the `Observable` to stop receiving items.
* The `.onNext()` method is called when an item is emitted by the `Observable`.
* The `.onComplete()` method is called when the `Observable` has finished sending items.
* The `.onError()` method is called when an error is encountered within the `Observable`. The specific error is passed to this method.

public interface Observer<T> {
    void onSubscribe(Disposable d);

    void onNext(T value);

    void onError(Throwable e);

    void onComplete();
}

# `.Next()`
The method `.onNext()` can be invoked zero, one, or multiple times by the `Observable` whereas the `.onComplete()` and `.onError()` methods are considered terminal events, meaning that if either of the two methods are called, no further method would be invoked on the `Observer`. This is a crucial contract of an `Observable` that must be enforced when creating an `Observable`.

> **Note:** More information will be covered in the lesson [Creating an Observable](https://www.educative.io/courses/reactive-programming-rxjava/creating-an-observable).

The method `.subscribe()` is also an overloaded method of an `Observable`. Depending on the `Observable` being subscribed to, sometimes it is not necessary to provide a "full" `Observer` when subscribing. For example, if we know that the `Observable` will never invoke the `.onComplete()` method in the case of an infinite stream, we can choose one of the other overloaded methods. The other options are as follows, and note that all these versions will return a `Disposable` object:

* The `.subscribe()` method: All methods are ignored. All errors will forward to the `RxJavaPlugins.onError()` handler. More information on this is in the chapter [Error Handling](https://www.educative.io/courses/reactive-programming-rxjava/introduction-gxA410RG9k3).

* The `.subscribe(Consumer<? super T> onNext)` method: Only `.onNext()` events are received.  All errors will be forwarded to the `RxJavaPlugins.onError()` handler.

* The `.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)` method: Only `.onNext()` and `.onError()` events are received and `.onComplete()` is ignored.

* The `.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)` method: All events are received.

* The `.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe)` method: All events are received. Additionally, a `Consumer` can be specified to receive the upstream's `Disposable` object.

>Previously in RxJava 1.x, if a method was omitted but called by the `Observable`--for example, the `.onComplete()` definition was not provided on subscription but called by the `Observable`--an exception would have been thrown. However, this was changed in RxJava 2 so that you don't have to provide a method definition if we are not concerned with certain events.

 Although the API is more forgiving now, we should still use an overloaded `.subscribe()` method with caution. In most cases, we would want to provide an `.onError()` definition and handle the error as appropriate for our use case.

# Push vs. Pull

Looking at the `Observable` and `Observer` definitions, we can see that the design is inherently a push-based system. An `Observer` will react upon receiving an item that was pushed to it by the `Observable` that it is subscribed to. However, this does not imply that emitted events are asynchronous. In fact, by default an `Observable` is synchronous, meaning that events will be emitted in the `Observable` stream on the same thread where `.subscribe()` is invoked.

Learn about the various methods offered by Observables and Observers.

Getting Started

Part 1: RxJava Basics

Reactive Programming

RxJava Core Components

Operators

Multithreading

Part 2: RxJava Advanced

Reactive Modeling on Android

Backpressure

Error Handling

Conclusion

Observable and Observer