Types of Observables in RxJava

21 Sep, 2021
In the model-view paradigm, this class represents an observable object, or “data.” It can be subclassed in order to represent an object that the application wishes to watch. The issue is that you’re creating software that will render data describing a three-dimensional scene in two dimensions. The application must be modular and allow for numerous, concurrent views of the same scene. 
One or more observers can be assigned to an observable object. An observer can be any object that implements the Observer interface. When an observable instance changes, an application that calls the Observable’s notifyObservers() method notifies all of its observers of the change through a call to their update method.
Image 1. The Observables in RxJava Explained.
In simple terms,  
An Observable is analogous to a speaker that broadcasts the value. It does various tasks and generates some values.
An Operator is similar to a translator in that it converts/modifies data from one form to another.
An Observer is what fetches the value.
The many types of Observables in RxJava are as follows:
Observable
Flowable
Single
Maybe
Completable
Let’s commence creating some Observables in RxJava to better understand this,  
Type #1: Creating a Basic Observable
Use Case: Assume you are downloading a file and need to push the current status of the download. You will have to emit more than one value in this case.
Kotlin
fun downloadObserervable(): Observable<Int> {    return Observable.create { gfgshooter ->        // Declaring an emitter in name of gfgshooter.        // Beginning the task (in this case a simple download)        // Your code...        if (!gfgshooter.isDisposed) {             // emit the progress            gfgshooter.onNext(20)        }        // Still Downloading        if (!gfgshooter.isDisposed) {             // send progress            gfgshooter.onNext(80)        }        // Progress 100, Download Over        if (!gfgshooter.isDisposed) {             // send progress            gfgshooter.onNext(100)             // send onComplete            gfgshooter.onComplete()        }    }}
 Type #2: Creating a Complex Obersever using Observable
Kotlin
fun getObserver(): Observer<Int> {    return object : Observer<Int> {        override fun onStart(d: Disposable) {             // Observation Started            // A sample editText            editText.setText("onStart")        }        override fun onNext(progress: Int) {            // Progress Updated            editText.setText("onNext : $progress")        }         override fun onError(e: Throwable) {            // Error Thrown            editText.setText("onError : ${e.message}")        }         override fun onComplete() {            // Observation Complete            editText.setText("onComplete")        }    }}
Observer <> Flowable
When the Observable emits a large number of values that cannot be absorbed by the Observer, the Flowable comes into play. In this scenario, the Observable must skip some data based on a strategy, otherwise, it will throw an exception. A strategy is used by the Flowable Observable to handle the exception. BackPressureStrategy is the strategy, and MissingBackPressureException is the exception. 
Geek Tip: Just like type #1, you can create Flowable using Flowable.create() similarly.
Solitary<> SingleObserver
When an Observable must emit only one value, such as as a response to a network request, Single is used.
Type #3: Creating Single Observable 
Kotlin
fun singleObservable(): Single<String> {    return Single.create { emitter ->        // any code which has a task        if (!gfgEmitter.isDisposed) {            gfgEmitter.onSuccess("Spandan's Code Ran!")        }    }}
 Then use it with a single observable in the following manner: 
Kotlin
fun singleObservable(): SingleObserver<String> {    return object : SingleObserver<String> {        override fun onSubscribe(d: Disposable) {            edittext.setText("onStart")        }         override fun onSuccess(data: String) {            // Successfully Executed            editText.setText("onSuccess : $data")        }         override fun onError(e: Throwable) {            // Error or Exception thrown.           editText.setText("onError : ${e.message}")        }    }}
 The maybe <> Observer
When the Observable must emit a value or no value, maybe is used.
Type #4: Creating a maybe Observer 
Kotlin
fun maybeObservable(): Maybe<String> {    return Maybe.create { gfgemitter ->        // your code goes here        if (!gfgemitter.isDisposed) {            gfgemitter.onSuccess("Spandan's Code!")        }    }}
 Completable <> CompletableObserver
When the Observable must do some job without emitting a value, it is called a Completable.
Type #5: Creating a Completable Observer 
Kotlin
fun completeObservable(): Completable {    return Completable.create { gfgemitter ->        // your code here        if (!gfgemitter.isDisposed) {            gfgemitter.onComplete()        }    }}
Using it now in the following manner: 
Kotlin
fun completeObservable(): gfgObserver {    return object : gfgObserver {        override fun onStart(d: Disposable) {            // Started            editText.setText("Started")        }        override fun onError(e: Throwable) {            // Exception Thrown            editText.setText("onError : ${e.message}")        }        override fun onComplete() {            // Completed            editText.setText("Done")        }    }}
The class combines the properties of a view (it textually shows the value of the model’s current state) with a controller (it allows the user to enter a new value for the state of the model). With help of this article, you would have now known how to create an Observable in any way you want and then use it as your procured use case.
 
sagar0719kumar
adnanirshad158
Picked
RxJava
Android
Kotlin
Android
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
How to Add Views Dynamically and Store Data in Arraylist in Android?
Android SDK and it's Components
Flutter - Custom Bottom Navigation Bar
How to Communicate Between Fragments in Android?
Retrofit with Kotlin Coroutine in Android
How to Add Views Dynamically and Store Data in Arraylist in Android?
Android UI Layouts
Kotlin Array
How to Communicate Between Fragments in Android?
Retrofit with Kotlin Coroutine in Android