Essa palestra fala sobre o uso de RxJava e RxAndroid am projetos de Android nativo. Explicando suas vantagens e, relações as APIs nativas do mundo Android.

1. RxJava
Um pouco sobre programação assíncrona e streams
1

2. O objetivo dessa apresentação é
mostrar um pouco do poder do
RxJava o porque dele ser incrível
2

3. Quem sou eu
• Clêrton Leal
• Nascido e criado em Fortaleza
• Vivendo em Belo Horizonte a pouco mais de 2 meses
• Atualmente trabalhando como consultor para Avenue Code
3

4. Um pouco de história
Será rápido eu prometo =)
4

5. Reactive Extensions é uma biblioteca, de programação
orientada a eventos, desenvolvida pela Microsoft e liberada
para o .NET framework em 2011.
Implementa e extende o padrão Observable clássico, porem
com um tratamento mais refinado para threads.
5

6. Em 2012 a Netflix adota o uso de Reactive Extensions para
seus módulos escritos em .NET e fica surpresa com a
facilidade de programação assíncrona.
Em 2013 a Netflix libera um projeto open source chamado
RxJava, uma implementação da especificação RX para Java.
Possibilitando assim o uso de RX em todos os seus módulos
escritos em Java e Scala.
6

7. Linguagems
7

8. • Java: RxJava
• JavaScript: RxJS
• C#: Rx.NET
• C#(Unity): UniRx
• Scala: RxScala
• Clojure: RxClojure
• C++: RxCpp
8

9. • Ruby: Rx.rb
• Python: RxPY
• Groovy: RxGroovy
• JRuby: RxJRuby
• Kotlin: RxKotlin
• Swift: RxSwift
• PHP: RxPHP
9

10. Uma sintaxe única
para todas as
linguagens
10

11. RxJava
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> observer) {
try {
for (int i = 1; i < 5; i++) {
observer.onNext(i);
}
observer.onCompleted();
} catch (Exception e) {
observer.onError(e);
}
}
} );
11

12. RxGroovy
def myObservable = Observable.create({ aSubscriber ->
try {
for (int i = 1; i < 5; i++) {
aSubscriber.onNext(i);
}
aSubscriber.onCompleted();
} catch(Throwable t) {
aSubscriber.onError(t);
}
})
12

13. RxSwift
let source = Observable.create { observer in
do {
for i in 1...5 {
observer.on(.Next(i))
}
observer.on(.Completed)
} catch {
observer.on(.Error)
}
}
13

14. Qual a grande jogada do RxJava
14

15. 15

16. RX trás a união e
expansão de dois
padrões de projeto
16

17. Observable
17

18. Iterator
18

19. Observable extendido
19

20. Adicionando a isso
funções de
transformação e
tratamento
assíncrono de dados
20

21. Entre o Observable e
o Subscriber
podemos aplicar
diversas funções de
transformação
21

22. Um pequeno
disclaimer sobre Java
8
22

23. Aplicando um filtro
String[] search = {"google", "microsoft"};
Observable.from(search)
.filter(s -> s.contains("g"))
.subscribe(s -> {
Log.d(TAG, s);
});
23

24. 24

25. Vamos adicionar o
controle de threads
25

26. String[] search = {"google", "microsoft"};
Observable.from(search)
.filter(s -> complexAndSlowFilter(s))
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(s -> {
Log.d(TAG, s);
});
26

27. Schedulers
• Schedulers.computation() - Usado para ações em CPU
bound em multi thread.
• Schedulers.io() - Usado para ações em IO bound.
• Schedulers.newThread() - Execução em nova thread.
• Schedulers.immediate() - Execução na thread atual.
• Schedulers.trampoline() - Execução na thread atual, mas
apenas após outras ações enfileiradas.
27

28. Schedulers
AndroidSchedulers.mainThread()
Main thread de uma aplicação Android.
28

29. Vamos para um
exemplo pratico
29

30. Em quantas linhas?
• Campo de texto irá buscar em um
serviço web
• Buscas feitas apenas com pelo
menos 3 caracteres
• Buscas feitas apenas quando o
usuário passar 500 milissegundos
sem digitar
30

31. Precisamos criar um observable
do SearchView
public Observable<String> getSearchObservable(SearchView searchView) {
return Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String query) {
return false;
}
@Override
public boolean onQueryTextChange(String newText) {
subscriber.onNext(newText);
return true;
}
});
}
});
}
31

32. E depois aplicar algumas
transformações
public Observable<String> getSearchObservable(SearchView searchView) {
return Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
@Override
public boolean onQueryTextSubmit(String query) {
return false;
}
@Override
public boolean onQueryTextChange(String newText) {
subscriber.onNext(newText);
return true;
}
});
}
}).filter(s -> fragment != null)
.map(s -> "http://search.com.br/" + s)
.filter(s -> s.length() >= 3)
.debounce(500, TimeUnit.MILLISECONDS)
.observeOn(AndroidSchedulers.mainThread())
.observeOn(Schedulers.computation());
32

33. E apenas isso na sua camada de
visão
getSearchObservable(searchField).subscribe(s -> {
doRequest();
})
33

34. Vamos ver alguns
truques legais com
RxJava
34

35. Facil de cancelar
• Sempre que chamamos o método subscribe(), o retorno do
mesmo é uma Subscription.
• Uma subscription pode ser facilmente cancelada.
Subscription subscription = getSearchObservable(searchField).subscribe(s -> {
doRequest();
});
subscription.unsubscribe();
35

36. Morte a AsyncTask
36

37. AsyncTasks são
tóxicas para o seu
código.
37

38. AsyncTask<String, String, User> asyncTask = new AsyncTask<String, String, User>() {
@Override
protected void onPreExecute() {
// Show a progress dialog
}
@Override
protected User doInBackground(String... params) {
return getUserSync(params[0]);
}
@Override
protected void onPostExecute(User s) {
// Update the UI
}
@Override
protected void onProgressUpdate(String... values) {
// Notify progress
}
};
38

39. Método getUser
public Observable<User> getUser(String name) {
return Observable.create((Observable.OnSubscribe<User>) subscriber -> {
try {
User user = getUserSync(name);
subscriber.onNext(user);
subscriber.onCompleted();
} catch (IOException e) {
subscriber.onError(e);
}
}).subscribeOn(Schedulers.io());
}
39

40. Consumindo getUser
private void doRequest() {
getUser("José")
.observeOn(AndroidSchedulers.mainThread())
.subscribe(user -> {
updateUi(user);
}, throwable -> {
handleError(throwable);
});
}
40

41. Ou apenas use o Retrofit
@GET("/{name}")
Observable<User> getUser(@Path("name") String name);
41

42. Morte a TimerTask
42

43. Um timer simples com RxJava
Subscription subscription = Observable.timer(START_DELAY, POLL_INTERVAL, TimeUnit.SECONDS)
.subscribe(aLong -> {
Log.d(TAG, String.valueOf(aLong));
});
subscription.unsubscribe();
43

44. A simplicidade de
fazer tarefas de forma
assíncrona abre novas
possibilidades
44

45. Qualquer operação de IO deve ser
realizada em uma thread
separada. Isso inclui acesso a
banco de dados e
SharedPreferences
45

46. O maior motivo se
adotar RxJava é o
suporte da
comunidade
46

47. Existem muitas bibliotecas com
Suporte a RxJava
• Retrofit: https://github.com/square/retrofit
• RxBinding: https://github.com/JakeWharton/RxBinding
• SqlBrite: https://github.com/square/sqlbrite
• Rx-preferences: https://github.com/f2prateek/rx-
preferences
47

48. Obrigado =)
Contatos
• clertonleal@gmail.com
• clertonleal
48