Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Android
Code

Começando com ReactiveX no Android

by
Difficulty:IntermediateLength:MediumLanguages:

Portuguese (Português) translation by Santhyago Gallão (you can also view the original English article)

Introdução

Desenvolver um aplicativo Android complexo que tem muitas conexões de rede, interações do usuário, e animações, na maioria das vezes, significa escrever um código cheio de retornos de chamada aninhadas. Esse código, às vezes chamado de callback hell (inferno de callbacks), não só é demorado e difícil de entender, mas também propenso a erros. O ReactiveX oferece uma abordagem alternativa, que é clara e concisa, para gerenciar tarefas e eventos assíncronos.

RxJava é uma implementação da JVM com ReactiveX, desenvolvida pela Netflix, e é muito popular entre os desenvolvedores Java. Neste tutorial, você vai aprender a usar ligações RxJava para o Android, ou simplesmente RxAndroid, nos seus projetos Android.

1. Configurando o RxAndroid

Para usar RxAndroid em um projeto no Android Studio, adicione-o como uma dependência compile em build.gradle do módulo app.

2. Noções básicas de Observers e Observables

Ao trabalhar com ReactiveX, você vai usar observables ​​e observers extensivamente Você pode pensar em um observable como um objeto que emite dados e um observer como um objeto que consome esses dados. Em RxJava e RxAndroid, os observers são instâncias da interface Observer e observables ​​são instâncias da classe Observable.

A classe Observable tem muitos métodos estáticos, chamados operators, para criar objetos Observable. O código a seguir mostra como usar o operador just para criar uma forma muito simples de um Observable que emite uma String.

O observable que acabamos de criar irá emitir seus dados somente quando ele tiver pelo menos um observer. Para criar um observer, você criar uma classe que implementa a interface Observer. A interface Observer nomeou intuitivamente métodos para lidar com os diferentes tipos de notificações que podem receber a partir do observable. Aqui está um observer que pode imprimir a String emitida pelo observable que criamos anteriormente:

Para atribuir um observer a um observable, você deve usar o método  subscribe, que retorna um objeto de Subscription. O código a seguir faz o myObserver observar o myObservable:

Assim que um observer é adicionado à um observable, ele emite seus dados. Portanto, se você executar o código agora, você vai ver um Hello impresso na janela do logcat do Android Studio.

Você deve ter notado que nós não utilizamos os métodos onCompletedonError no myObserver. Como esses métodos muitas vezes não são utilizados, você também tem a opção de usar a interface Action1, que contém um único método chamado call.

Quando você passa uma instância de Action1 para o método subscribe, o método call será chamado sempre que o observable emitir dados.

Para desconectar um observer do seu observable enquanto observable ainda está emitindo dados, você pode chamar o método unsubscribe do objeto Subscription.

3. Usando os operadores

Agora que você sabe como criar observers e observables, deixe-me mostrar-lhe como usar os operadores do ReactiveX que podem criar, transformar e executar outras operações nos observables. Vamos começar criando um Observable ligeiramente mais avançado, que emite os itens de um array de objetos Integer. Para fazer isso, você tem que usar o operador from, que pode gerar um Observable de arrays e listas.

Quando você executa esse código, você verá cada um dos números do array impressos um após o outro.

Se você estiver familiarizado com JavaScript, Ruby ou Kotlin, você pode também estar familiarizado com as funções higher-order (funções que recebem outras funções como argumento e/ou que retornam uma função) como map e filter, que podem ser usadas ao trabalhar com arrays. O ReactiveX tem operadores que podem executar operações semelhantes em observables. No entanto, como o Java 7 não tem funções lambda e higher-order, nós teremos que criá-las usando classes que simulam lambdas. Para simular um lambda que recebe um argumento, você terá que criar uma classe que implementa a interface  Func1.

Aqui está como você pode usar o operador map para elevar ao quadrado cada item de myArrayObservable:

Note que a chamada para o operador map retorna um novo Observable, que não muda o Observable original. Se você se inscrever agora para observar o myArrayObservable, você receberá os quadrados dos números.

Os operadores podem ser encadeados. Por exemplo, o bloco de código a seguir usa o operador skip para ignorar os primeiros dois números e em seguida o operador filter para ignorar os números ímpares:

4. Lidando com tarefas assíncronas

Os observers e observables que criamos nas seções anteriores rodam em uma única thread, a thread da UI do Android. Nesta seção, mostrarei como usar o ReactiveX para gerenciar várias threads e como ReactiveX resolve o problema do inferno de callbacks.

Suponhamos que você tenha um método chamado fetchData que pode ser usado para buscar dados de uma API. Digamos que ele aceita uma URL como seu parâmetro e retorna o conteúdo da resposta como uma String. O trecho de código a seguir mostra como poderia ser usado.

Este método precisa ser executado na sua própria thread, pois o Android não permite operações de rede na thread de UI. Isto significa que você poderia criar uma AsyncTask ou criar uma Thread que usa um Handler.

Com ReactiveX, no entanto, você tem uma terceira opção que é ligeiramente mais concisa. Usando os operadores de subscribeOn e observeOn, você pode explicitamente especificar qual thread deve executar a tarefa em segundo plano e qual thread deve lidar com as atualizações da UI.

O código a seguir cria um Observable personalizado usando o operador create. Quando você cria um Observable desta maneira, você tem que implementar a interface Observable.OnSubscribe e controlar por si mesmo o que ela emite chamando os métodos onNext, onError e onCompleted.

Quando Observable está pronto, você pode usar o subscribeOn e o observeOn para especificar quais threads ele deve usar e se inscrever nelas.

Você ainda pode estar pensando que a abordagem reativa (Reactive) não é tão melhor do que usar as classes AsyncTask ou Handler. Você está certo, você realmente não precisa de ReactiveX para gerenciar apenas uma tarefa em segundo plano.

Porém, considere um cenário que resultaria em uma base de código complexa na qual você usou a abordagem convencional. Digamos que você tem que buscar dados de dois (ou mais) sites em paralelo e atualizar uma View somente quando todas as requisições acabarem. Se você seguir a abordagem convencional, você teria que escrever muito código desnecessário para certificar-se que as requisições foram concluídas sem erros.

Considere um outro cenário em que você tem que iniciar uma tarefa em background somente após outra tarefa em background, for concluída. Usando a abordagem convencional, o resultado seriam callbacks aninhados.

Com os operadores do ReactiveX, ambos os cenários podem ser tratados com muito pouco código. Por exemplo, se você precisa usar fetchData para buscar o conteúdo de dois sites, por exemplo Google e Yahoo, você poderia criar dois objetos do tipo Observable e usar o método subscribeOn para fazê-los rodar em diferentes threads.

Para lidar com o primeiro cenário, em que ambas as solicitações precisam ser executados em paralelo, você pode usar o operador zip e inscrever-se no Observable que ele retorna.

Da mesma forma, para lidar com o segundo cenário, você pode usar o operador concat para executar as threads uma após a outra.

5. Tratamento de eventos

O RxAndroid tem uma classe chamada ViewObservable que torna mais fácil manipular eventos associados a objetos View. O trecho de código a seguir mostra como criar um ViewObservable que pode ser usado para manipular os eventos de clique de um Button.

Você pode agora inscrever-se no clicksObservable e usar qualquer um dos operadores que você aprendeu nas seções anteriores. Por exemplo, se você quer seu app ignore os primeiros quatro cliques do botão e comece a responder do quinto clique em diante, você pode usar a seguinte implementação:

Conclusão

Neste tutorial, você aprendeu como usar os observers, observables e os operadores do ReactiveX para manipular inúmeras operações e eventos assíncronos. Como trabalhar com ReactiveX envolve programação funcional, reativa, um paradigma de programação que a maioria dos desenvolvedores Android não estão acostumados a utilizar, não seja muito duro consigo mesmo se você não acertar na primeira vez. Você também deve saber que o código de ReactiveX será muito mais legível se você usar uma linguagem de programação moderna, tais como Kotlin, que oferece suporte a funções higher-order.

Para saber mais sobre extensões reativas, lhe aconselho a procurar os recursos disponíveis no ReactiveX.

Seja o primeiro a saber sobre novas traduções–siga @tutsplus_pt no Twitter!

Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.