La forma más sencilla de crear un observable es utilizar los métodos de fabricación que se implementan en la biblioteca RxJava. Ya usamos el método Observable.from(), en un post anterior.
Observable.just() crea un Observable que emite el objeto o los objetos que se pasan como parámetros:
Observable.just(1, 2, 3, 4, 5)
Observable.range (a, n) crea un Observable que emite un rango de n enteros consecutivos a partir de a :
Observable.range(1, 5)
Observable.interval (long, TimeUnit) : crea un Observable que emite una secuencia de enteros a partir de 0 que están espaciados por un intervalo de tiempo dado. El primer argumento es la cantidad de tiempo y el segundo argumento define la unidad de tiempo. El siguiente observable emite un elemento cada 1 segundo:
Observable.interval(1, TimeUnit.SECONDS)
La secuencia es una secuencia infinital, por lo que onCompleted nunca será notificado. La secuencia se detiene solo cuando no hay más observadores conectados (suscritos) a lo observable.
Observable.timer (long, TimeUnit) crea un Observable que emite solo un elemento después de un retraso determinado.
Observable.create () es el método permite crear un Observable desde cero. Por ejemplo, si desea crear un observable que emita solo una cadena, "¡Hola!", Puede escribir :
Observable.create(
new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> observer) {
observer.onNext("Hello!");
observer.onCompleted();
}
}
);
Observable.empty () crea un Observable que emite una secuencia vacía (cero elementos) y luego se completa. Por lo tanto, solo se notificará a onCompleted().
Puede ser útil si desea emitir una secuencia vacía en lugar de emitir elementos nulos o arrojar errores
Observable.error (throwable) crea un Observable que emite una secuencia vacía (cero elementos) y luego notifica un error. Por lo tanto, solo se llamará a onError().
Observable.never () crea un Observable que emite una secuencia vacía (cero elementos) y nunca se completa. No se invocará ningún método del observador.
Observable.defer () crea un Observable solo cuando un suscriptor se suscribe.
La mejor manera de explicar qué hace defer () es con el siguiente ejemplo. Empecemos por la clase Persona, que tiene dos campos: nombre y edad.
class Person {
private String name;
private int age;
// geter y setters
}
Ahora creamos una instancia de Person, y dos Observables para ser notificados con los valores de edad y nombre :
// create a new instance of Person
final Person person = new Person();
Observable<String> nameObservable = Observable.just(person.getName());
Observable<Integer> ageObservable = Observable.just(person.getAge());
// set age and name
person.setName("Bob");
person.setAge(35);
ageObservable.subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer age) {
System.out.println("age is: " + age);
}
});
nameObservable.subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String name) {
System.out.println("name is: " + name);
}
});
¿Qué sucede cuando llama a los métodos observeName () y observeAge () en una instancia de Person? ¿Cuál será la secuencia emitida por los observables? Desafortunadamente, la salida será
El problema aquí es que Observable.just() se evalúa tan pronto como se invoca, por lo que creará una secuencia utilizando el valor exacto de ese nombre y referencia de edad cuando se crea el observable. En el ejemplo, cuando se crea el observable, la edad es 0 y el nombre es nulo.
Para esto existe Observable.defer ().
Observable<String> nameObservable = Observable.defer(new
Func0<Observable<String>>() {
@Override
public Observable<String> call() {
return Observable.just(person.getName());
}
});
Observable<Integer> ageObservable = Observable.defer(new Func0<Observable<Integer>>() {
@Override
public Observable<Integer> call() {
return Observable.just(person.getAge());
}
});
Al usar estos dos observables, la salida de los ejemplos anteriores se convierte en
