Descripción de los operadores de temporizador, retraso e intervalo de RxJava

Aprenderemos sobre los operadores RxJava Timer, Delay e Interval en esta publicación. Además, el caso de uso de todos los diferentes temporizadores, retrasos y operadores de intervalo se aclarará en este artículo, así que permanezca atento hasta el final. Con ejemplos, estudiaremos todas las operaciones siguientes.

• Temporizadores
• Retrasos
• Intervalo

Comencemos con el operador de temporizador RxJava. El operador Timer se usa cuando queremos hacer algo después de una cierta cantidad de tiempo. 

Ejemplo de operador de temporizador

Observable.timer(5, TimeUnit.SECONDS)
    .flatMap {
        return@flatMap Observable.create<String> { shooter ->
            Log.d("gfgArticleExampe", "Shoot")
            shooter.onNext("GeeksforGeeks")
            shooter.onComplete()
            // Action to be done when completed 10 secs
        }
    }
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe {
        Log.d("gfgArticleExampe", it)
}

El ejemplo anterior nos muestra lo que llamamos un operador de temporizador. Como hemos pasado 10 segundos en el operador del temporizador, luego pasará a la otra tarea de esta manera, completamos la tarea en 10 segundos y emitimos el valor «GeeksforGeeks».

GeekTip # 1: cuando tenemos un caso de uso en el que deseamos completar un trabajo después de una cierta cantidad de tiempo, podemos usar el Operador de temporizador.

Ahora, echemos un vistazo al operador de retraso RxJava. El Operador de Retraso cambia las emisiones de un Observable adelante en el tiempo por una cantidad específica. Veamos un ejemplo del operador Delay.

Ejemplo de operador de retardo

Observable.create<String> { emitter ->
    Log.d("DelayGFG", "Shoot")
    emitter.onNext("GeeksforGeeks")
    emitter.onComplete()
}
.subscribeOn(Schedulers.io())
.delay(10, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe {
    Log.d("DelayGFG", it)
}

Estamos trabajando y luego emitiendo un valor, pero queremos posponer la emisión del valor al suscriptor, así que usamos el operador de retraso. 

Consejo geek #2: Cuando tenemos un caso de uso en el que deseamos ejecutar el trabajo primero y luego posponer la emisión por un período de tiempo específico, podemos usar el Operador de retraso.

Echemos un vistazo al operador de intervalo RxJava, que genera un Observable que emite una secuencia de enteros separados por un intervalo de tiempo.

Ejemplo de operador de intervalo

val disposable =
    Observable.interval(1, 10, TimeUnit.SECONDS)
        .flatMap {
            return@flatMap Observable.create<String> { shooter ->
                Log.d("GfGInterval", "Shoot")
                shooter.onNext("GeeksforGeeks")
                shooter.onComplete()
            }
        }
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe {
            Log.d("GfGInterval", it)
        }
compositeDisposable.add(disposable)

En este caso, la tarea se repetirá después de un retraso de 10 segundos. Una cosa a tener en cuenta: continuará indefinidamente.

¿Cómo deshacerse de este bucle entonces?

Bueno, hay dos formas de detenerse:

• Haciendo uso del compositeDisposable.
• dispose() se puede llamar usando el operador take(n).

Conclusión

Cuando tenemos un caso de uso en el que deseamos repetir un trabajo con un cierto intervalo de tiempo, podemos usar el Operador de intervalo. Otra cosa a tener en cuenta es que todos los operadores de temporizador, retraso e intervalo se ejecutan en el subproceso del programador, por lo tanto, no tenemos que preocuparnos por eso. Para abordar el problema intrigante, podemos utilizar los operadores RxJava Timer, Delay e Interval.