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

# Issue: Method signature

After making the changes, the first point to note is that the method signature is no longer the same. This may not be a big deal if this method call is only used in a few places and it’s easy to propagate the changes up to other areas of the stack. However, if it breaks clients relying on this method, that’s problematic, and the method signature should be reverted.

# Solution: Using `.blockingX()`

To address the first issue from our change, we can make use of any of the `.blockingX()` operators available to an `Observable`. Essentially, a `.blockingX()` operator blocks the calling thread until an item is emitted downstream. 

A few notable blocking operators that are available are:

* `.blockingFirst()` blocks the calling thread and returns the first element emitted by the `Observable`.

* `.blockingNext()` returns an `Iterable` which allows us to iterate through all the emissions by the `Observable`. Each iteration will block until the `Observable` emits a next item.

* The `.blockingLast()` operator blocks the calling thread and returns the last element emitted by the `Observable`.

* The `.blockingSingle()` operator blocks the calling thread until the `Observable` emits an element followed by an `.onComplete()` event. Otherwise, an `Exception` is thrown.

* The `.blockingSubscribe()` operator blocks until a terminal event is received. All elements that are received through `.onNext()` are ignored.

By using a blocking operator to change the method signature back to a `List<User>`, our snippet now looks like this:

Learn how to use the blocking operators to address the method signature issue.

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

RxJava's Consequences: Method Signature

Issue: Method signature

Solution: Using `.blockingX()`

RxJava's Consequences: Method Signature

Issue: Method signature

Solution: Using .blockingX()

Solution: Using `.blockingX()`