Implementar la búsqueda usando operadores RxJava

Hoy en día, la mayoría de los programas que utilizamos en nuestro día a día incluyen una opción de búsqueda que nos permite encontrar fácilmente lo que buscamos. Como resultado, tener una herramienta de búsqueda es fundamental. Y es nuestro trabajo como desarrolladores implementarlo mejor. Veamos cómo hacerlo mejor con los operadores RxJava.

Imagen 1. El RxSearch como en GfG.

Las siguientes funciones de RxJava se utilizarán para crear esta función de búsqueda:

Requisito previo: necesitaremos conocer las funciones básicas de RxJava, ya que implementar la búsqueda es algo complicado.

• Filtro de operador
• Rebote del operador
• Operador DistinctUntilChanged
• Operador de SwitchMap

¡Guau! aunque esto puede parecer que implementar una búsqueda es realmente difícil, pero NO. Es realmente fácil cuando lo hacemos paso a paso como se menciona a continuación en este artículo, y estará listo y funcionando en muy poco tiempo. ¡Además, todos los términos anteriores están vinculados a otros increíbles artículos de GfG para ampliar su aprendizaje! Sin más preámbulos, comencemos.

Implementación paso a paso

Paso n.º 1: hacer observable la vista de búsqueda

En primer lugar, debe hacer que SearchView sea visible. Usemos PublishSubject para hacer que SearchView sea observable. Aquí estamos haciendo uso de Android SearchView. La vista puede ser cualquier cosa que se parezca a EditText. Es solo que necesitará construir el oyente de cambio de texto para que esa vista sea visible.

public class GfGSearch {
    public static Observable<String> fromView(SearchView gfgSearch) {
        final gfgArticle<String> article = gfgArticle.create();
        gfgSearch.setOnQueryTextListener(new gfgSearch.OnQueryTextListener() {
            @Override
            public boolean onQueryTextSubmit(String s) {
                article.onComplete();
                return true;
            }
  
            @Override
            public boolean onQueryTextChange(String text) {
                article.onNext(text);
                return true;
            }
        });
  
        return article;
    }
}

Paso #2: Aplicar los Operadores

Debe usar las siguientes operaciones en ese observable SearchView:

@Override
public ObservableSource<String> apply(String query)
        {
            return dataFromNetwork(query)
                .doOnError(throwable
                           -> {
                              // Exception Handling
                           })
                .onErrorReturn(throwable -> "");
        }
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Consumer<String>() {
        @Override public void accept(String result)
        {
            searchResult.setText(result);
        }
    });
RxGfGSearch.fromView(searchView)
    .debounce(200, TimeUnit.MILLISECONDS)
    .filter(new Predicate<String>() {
        @Override public boolean test(String text)
        {
            if (text.isEmpty()) {
                searchResult.setText("Spandan");
                return false;
            }
            else {
                return true;
            }
        }
    })
    .distinctUntilChanged()
    .switchMap(new Function<String, ObservableSource<String> >() {

Comprender los términos que usamos en el código anterior:

DistinctUntilChanged: el operador distinguidoUntilChanged evita llamadas de red repetidas. Suponga que la consulta de búsqueda en curso más reciente fue «abc», y el usuario borró «c» antes de escribir «c» nuevamente. Así que es «abc» una vez más. Por lo tanto, si una llamada de red ya está en curso con la consulta de búsqueda «abc», no iniciará una llamada duplicada con la consulta de búsqueda «abc». Como resultado, differentUntilChanged evita que el Observable de origen emita elementos sucesivos duplicados.

• Filtro : el operador de filtro se usa para filtrar strings no deseadas, como la string vacía en este ejemplo, para evitar realizar una llamada de red innecesaria.
• rebote: El operador de rebote se emplea con una constante de tiempo en este caso. Cuando un usuario ingresa «a», «ab» o «abc» en un breve período de tiempo, el operador de rebote maneja la situación. Como resultado, habrá un exceso de llamadas de red. Sin embargo, el usuario está finalmente interesado en el resultado de la búsqueda «abc». Como resultado, los resultados de «a» y «ab» deben descartarse. Idealmente, ninguna red requiere «a» y «ab» porque el usuario los escribió en un período de tiempo muy corto. Como resultado, el operador antirrebote interviene para ayudar. Si llega otra consulta de búsqueda entre ese momento, el antirrebote descartará el elemento anterior y comenzará a esperar ese momento nuevamente con la nueva consulta de búsqueda. Si no llega nada nuevo dentro de ese período de tiempo constante, volverá a esa consulta de búsqueda para un procesamiento adicional. Como consecuencia, 
• SwitchMap : el operador switchMap se usa aquí para evitar resultados de llamadas de red que ya no son necesarios para mostrar al usuario. Suponga que la consulta de búsqueda más reciente fue «ab», hay una llamada de red activa para «ab» y el usuario ingresó «abc». Entonces ya no te interesa el resultado de «ab». Solo le preocupa el resultado de «abc». Como resultado, switchMap viene al rescate. Solo devuelve los resultados de la consulta de búsqueda más reciente e ignora las demás.

Consejo geek n.º 1: Devuelve un nuevo Observable aplicando la función dada a cada elemento emitido por la fuente.

Conclusión

Y sí, eso es todo en este artículo, ahora podría implementar un RxSearch usando RxJava, esta búsqueda se usa en muchos lugares como Netflix, Google e incluso Geeks for Geeks. ¡Imagínese lo duro que sería el mundo sin Rx!

Recuerde siempre: ¡
Hay algo para todo en RxJava!