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

# Cold observable
An `Observable` is considered cold if it is not actively emitting items. It only starts emitting items when it is subscribed to. Each subscription to a cold `Observable` will cause it to emit the underlying sequence from beginning to end for each `Observer`. 

>**Note:** The exact values of the sequence may differ for each `Observer`, depending on the underlying action the `Observable` encapsulates as we'll see more of this in the section [Lazy Emissions](https://www.educative.io/courses/reactive-programming-rxjava/lazy-emissions).

Generally, a cold `Observable` is what we would want if we want a complete copy of events emitted in the stream. It’s what we want for operations that should only be invoked when subscribed to: network operations, database queries, file I/O, and so on.

Looking at `.just()` as an example, we see that the sequence is repeated on each subscription:

Learn about the differences between cold and hot observables.

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

Cold vs. Hot Observables

Cold observable