Tipos de Observables en RxJava

En el paradigma modelo-vista, esta clase representa un objeto observable o «datos». Puede subclasificarse para representar un objeto que la aplicación desea observar. El problema es que está creando un software que representará datos que describen una escena tridimensional en dos dimensiones. La aplicación debe ser modular y permitir numerosas vistas simultáneas de la misma escena. 

Se pueden asignar uno o más observadores a un objeto observable. Un observador puede ser cualquier objeto que implemente la interfaz Observer. Cuando una instancia observable cambia, una aplicación que llama al método de notificaciónObservers () de Observable notifica a todos sus observadores del cambio a través de una llamada a su método de actualización.

Imagen 1. Explicación de los Observables en RxJava.

En lenguaje sencillo,  

• Un Observable es análogo a un altavoz que transmite el valor. Realiza varias tareas y genera algunos valores.
• Un Operador es similar a un traductor en que convierte/modifica datos de un formulario a otro.
• Un observador es lo que obtiene el valor.

Tipos observables en RxJava

Los muchos tipos de Observables en RxJava son los siguientes:

• Observable
• fluido
• Único
• Quizás
• Completable

Comencemos a crear algunos Observables en RxJava para comprender mejor esto,  

Tipo #1: Creando un Observable Básico

Caso de uso: suponga que está descargando un archivo y necesita actualizar el estado actual de la descarga. Tendrás que emitir más de un valor en este caso.

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()
        }
    }
}

 
Tipo #2: Creando un Observador Complejo usando Observable

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")
        }
    }
}

Observador <> Fluido

Cuando el Observable emite una gran cantidad de valores que no pueden ser absorbidos por el Observer, entra en juego el Flowable. En este escenario, el Observable debe omitir algunos datos en función de una estrategia, de lo contrario, generará una excepción. El Observable de flujo utiliza una estrategia para manejar la excepción. BackPressureStrategy es la estrategia y MissingBackPressureException es la excepción. 

Sugerencia geek: al igual que el tipo n. ° 1, puede crear Flowable usando Flowable.create() de manera similar.

Solitario<> Observador único

Cuando un Observable debe emitir solo un valor, como una respuesta a una solicitud de red, se usa Single.

Tipo #3: Creando un Observable Único 

fun singleObservable(): Single<String> {
    return Single.create { emitter ->
        // any code which has a task
        if (!gfgEmitter.isDisposed) {
            gfgEmitter.onSuccess("Spandan's Code Ran!")
        }
    }
}

 
Luego utilícelo con un solo observable de la siguiente manera: 

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}")
        }
    }
}

 
El tal vez <> observador

Cuando el Observable debe emitir un valor o ningún valor , se utiliza quizás.

Tipo #4: Crear un observador quizás 

fun maybeObservable(): Maybe<String> {
    return Maybe.create { gfgemitter ->
        // your code goes here
        if (!gfgemitter.isDisposed) {
            gfgemitter.onSuccess("Spandan's Code!")
        }
    }
}

 
Completable <> CompletableObserver

Cuando el Observable debe hacer algún trabajo sin emitir un valor , se llama Completable.

Tipo #5: Creación de un observador completable 

fun completeObservable(): Completable {
    return Completable.create { gfgemitter ->
        // your code here
        if (!gfgemitter.isDisposed) {
            gfgemitter.onComplete()
        }
    }
}

Usándolo ahora de la siguiente manera: 

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")
        }
    }
}

Conclusión

La clase combina las propiedades de una vista (muestra textualmente el valor del estado actual del modelo) con un controlador (permite al usuario ingresar un nuevo valor para el estado del modelo). Con la ayuda de este artículo, ahora sabrá cómo crear un Observable de la forma que desee y luego usarlo como su caso de uso adquirido.