1

Android Annotations: Ganhando produtividade no

desenvolvimento Android
Mentoring: apresentao do cenrio
Este artigo apresentar o desenvolvimento de um aplicativo em dois momentos: primeiro, o aplicativo
desenvolvido da maneira clssica, utilizando apenas o Eclipse + plugin ADT (embora j tenha sido a nica
possibilidade).
Esta certamente no a forma mais produtiva para se desenvolver sistemas em Android, pois, dentre outras
coisas, o cdigo acaba se tornando complexo, demorado e repetitivo. A segunda verso, do mesmo
aplicativo, far uso do Android Annotation, o qual simplifica muito a codificao do sistema permitindo um
aumento significativo de produtividade em seu desenvolvimento.
Alm disso, o cdigo gerado com o uso de Annotations mais fcil de ser mantido durante a evoluo do
software uma vez que temos um cdigo muito mais limpo e fcil de entender, com uma queda considervel
na complexidade de desenvolvimento se comparado com o modo clssico.
Autores: Robison Cris Brito e Evaldo Augusto Bianchi
Desenvolver aplicativos para dispositivos mveis, em especial para a plataforma Android, era um grande
desafio quando a plataforma foi lanada, com poucos recursos e um ambiente de desenvolvimento bastante
limitado.
Era necessrio digitar os cdigos em um editor de cdigo separado, acessar o prompt de comando do sistema
operacional para s ento ter acesso a recursos como compilao e execuo do aplicativo no emulador.
Hoje as ferramentas de desenvolvimento evoluram muito, e uma IDE que merece grande destaque para o
desenvolvimento Android a IDE Eclipse, em especial, com a instalao do plugin ADT.
Esta IDE preparada com o plugin permite otimizar o desenvolvimento de aplicativos Android, em especial,
pela simplicidade de codificar um aplicativo e execut-lo diretamente da IDE, assim como permitindo
recursos de depurao, integrao de recursos com o emulador, possibilidade de gerenciar as AVD (Android
Virtual Device) e o prprio Android SDK, tudo isso de dentro do Eclipse.
O problema
Entretanto, o processo de desenvolvimento para a plataforma Android continua um tanto quanto limitada,
ainda mais no que diz respeito a produtividade. Muitos programadores utilizam o desenvolvimento Android
na forma mais clssica de codificao, criando a interface grfica no arquivo XML, aps codificando a
Activity (cdigo .java), fazendo todos os findViewById(), um para cada componente visual utilizado, alm
dos tratamentos de eventos utilizando Listener, desenvolvimento de Thread para execuo em background,
enfim, apesar de muitos recursos na plataforma, o desenvolvimento continua muito improdutivo.
A soluo
Para melhorar este quesito a produtividade foi lanado o Android Annotation, o qual facilita o
desenvolvimento de uma srie de atividades simples, porm, morosas, aumentando assim significativamente
a produtividade e evitando erros de codificao simples.
Cenrio para analisar o problema e a soluo
2

Para testar e demonstrar alguns recursos do Android Annotations, vamos desenvolver inicialmente um
aplicativo utilizando os recursos do Android clssico. Este aplicativo ser chamado de AplicativoExemplo.
Dica. Desenvolvimento do aplicativo
Como o desenvolvimento deste aplicativo visa apresentar o uso da biblioteca Android Annotations, recursos
bsicos como preparao do ambiente de desenvolvimento (instalao do eclipse, instalao e configurao
do plugin ADT, criao da AVD, entre outros) no sero apresentados, assim como os passos para criar um
projeto e desenvolver uma nova Activity tambm no sero detalhados.
O aplicativo ter duas telas, a tela principal contendo uma lista esttica e um boto com o texto Adicionar,
a segunda tela ser apresentada aps o clique no boto existente na primeira tela, e nenhum processamento
especfico ser realizado nesta segunda tela.
As interfaces grficas tero o nome de activity_main.xml e activity_adicionar.xml, e as classes
respectivamente MainActivity.java e AdicionarActivity.java. A estrutura do projeto apresenta na Figura 1.

Figura 1. Estrutura do projeto para demonstrar o uso do Annotations.
Desenvolvimento Inadequado
O cdigo referente interface da tela principal apresentado na Listagem 1. O cdigo apresentado utiliza o
layout linear (linha 1), um boto (linha 6) e uma lista (linha 12).
Listagem 1. activity_main.xml Cdigo da interface principal.
3

1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
2. android:layout_width="fill_parent"
3. android:layout_height="fill_parent"
4. android:orientation="vertical" >
5.
6. <Button
7. android:id="@+id/btAdicionar"
8. android:layout_width="match_parent"
9. android:layout_height="wrap_content"
10. android:text="Adicionar" />
11.
12. <ListView
13. android:id="@+id/lvItem"
14. android:layout_width="match_parent"
15. android:layout_height="match_parent"
16. android:choiceMode="singleChoice"
17. android:divider="#FFFFFF" />
18.
19.</LinearLayout>
Os cdigos das linhas 7 e 13 representam o identificador do componente que ser utilizado na classe
MainActivity.java, cujo cdigo est representado, na forma clssica de desenvolvimento Android, conforme
Listagem 2.
Listagem 2. MainActivity.java Classe da tela principal sem annotations.
1. package br.edu.utfpr.aplicativoexemplo;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5.
6. import android.app.Activity;
7. import android.app.ProgressDialog;
8. import android.content.Intent;
9. import android.os.AsyncTask;
10.import android.os.Bundle;
11.import android.util.Log;
12.import android.view.View;
13.import android.view.Window;
14.import android.view.WindowManager;
15.import android.widget.ArrayAdapter;
16.import android.widget.Button;
17.import android.widget.ListView;
18.import android.widget.Toast;
19.
20.public class MainActivity extends Activity {
21.
22. private ListView listViewItem;
23. private Button buttonAdicionar;
24. private ProgressDialog progress;
25. private List<String> itens;
26.
27. @Override
28. protected void onCreate(Bundle savedInstanceState) {
29. super.onCreate(savedInstanceState);
30.
31. requestWindowFeature(Window.FEATURE_NO_TITLE);
32. getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
33. WindowManager.LayoutParams.FLAG_FULLSCREEN);
34.
35. setContentView(R.layout.activity_main);
36.
37. progress = new ProgressDialog(this);
38. progress.setCancelable(false);
4

39. progress.setProgressStyle(ProgressDialog.STYLE_SPINNER);
40. progress.setMessage("Carregando os itens");
41.
42. listViewItem = (ListView) findViewById(R.id.lvItem);
43. buttonAdicionar = (Button) findViewById(R.id.btAdicionar);
44.
45. itens = new ArrayList<String>();
46.
47. CarregarItens task = new CarregarItens();
48. task.execute();
49.
50. buttonAdicionar.setOnClickListener(new View.OnClickListener() {
51. @Override
52. public void onClick(View v) {
53. Intent adicionar = new Intent(MainActivity.this,
54. AdicionarActivity.class);
55. startActivity(adicionar);
56. }
57. });
58. }
59.
60. class CarregarItens extends AsyncTask<Void, Void, Boolean> {
61.
62. @Override
63. protected void onPreExecute() {
64. progress.show();
65. }
66.
67. @Override
68. protected Boolean doInBackground(Void... params) {
69. try {
70. Thread.sleep(5000);
71.
72. itens.add("Item exemplo 1");
73. itens.add("Item exemplo 2");
74. itens.add("Item exemplo 3");
75.
76. } catch (InterruptedException e) {
77. Log.i("Erro", e.getMessage());
78. return false;
79. }
80.
81. return true;
82. }
83.
84. @Override
85. protected void onPostExecute(Boolean result) {
86. listViewItem.setAdapter(new ArrayAdapter<String>(MainActivity.this,
87. android.R.layout.simple_list_item_1, itens));
88. progress.dismiss();
89.
90. if (!result)
91. Toast.makeText(MainActivity.this, "Erro ao carregar os itens",
92. Toast.LENGTH_LONG).show();
93. }
94. }
95.}
Na listagem apresentada inicialmente a importao das classes utilizadas no aplicativo (linha 3 a 18),
assim como a declarao da MainActivity (linha 20).
Aps isso, os componentes visuais que sero utilizados so declarados (linha 22 a 24), sendo os dois
primeiros componentes de tela e o terceiro um componente dinmico, que representar uma barra de
progresso.
5

A linha 25 declara um List, o qual armazenar os itens do ListView, este presente na tela inicial.
Em seguida, o mtodo onCreate() linha 28 declarado, assim como a chamada do seu mtodo na classe
pai (linha 29). As linhas 31 a 33 so responsveis por deixar o aplicativo em tela cheia, sem as barras de
ttulo, e a linha 35 apresenta na tela do device a interface grfica definida no arquivo activity_main.xml.
J as linhas 37 a 40 so responsveis pela instanciao da barra de progresso, o qual apresentado enquanto
supostamente os itens da lista so carregado. As linhas 42 e 43 so responsveis por mapear os componentes
presentes na tela principal. Por fim, a linha 45 instncia o objeto de ArrayList, o qual receber os elementos
apresentados no ListView.
Duas linhas importantes para o aplicativo proposto so as 47 e 48, responsveis por executar uma Thread em
paralelo, responsvel por carregar os itens no ListView. A classe CarregarItens apresentada com detalhes a
partir da linha 60.
O processamento do boto adicionar realizado das linhas 50 a 57, e sua funo simplesmente criar um
Intent (linha 53) para chamar a Activity AdicionarActivity.java, esta corresponde segunda janela do
aplicativo.
A linha 60 declara uma nova Thread, esta chamada de CarregarItens. Esta classe herda funcionalidades de
AssyncTask, o que permite a execuo de uma tarefa assncrona (em paralelo ao processamento principal).
Ao utilizar a AssyncTask, trs mtodos devem ser codificados: onPreExecute(), doInBackground() e
onPostExecute().
O mtodo onPreExecute() linha 63 responsvel pelo cdigo antes da execuo da tarefa assncrona. No
exemplo, ele simplesmente apresenta para o usurio a barra de progresso (linha 64).
O mtodo doInBackground() linha 68 o processamento de fundo, propriamente dito, ele faz uma pausa
de 5 segundos (linha 70), para s ento adicionar trs elementos estticos na lista (linhas 72 a 74). Esta
lgica poderia ser substituda por um acesso a rede, por exemplo, porm, para simplificar, foi optado apenas
pela incluso de dados estticos na tela.
Ao final do processamento em paralelo, o mtodo onPostExecute() linha 85 executado, associando os
elementos adicionados no ArrayList ao componente ListView, utilizando para isso um ArrayAdapter (linha
87). Por fim, o progressBar retirado da tela (linha 88).
Assim, ao executar o aplicativo, a tela da Figura 2 apresentada para o usurio, permanecendo cinco
segundos na tela.
6


Figura 2. Tela para carregamentos dos elementos no ListView.
Depois desse tempo, o componente ListView formatado e apresentado para o usurio, conforme Figura 3.

Figura 3. Tela com os elementos carregados.
Ao clicar no boto adicionar, ser aberta uma nova janela. Esta ser criada automaticamente pelo Eclipse,
conforme apresentado na Figura 4.
7


Figura 4. Tela com os elementos carregados.
Anlise da situao problema
No aplicativo desenvolvido, temos uma tarefa simples, exibir uma pequena lista na tela e abrir uma nova tela
ao pressionar um boto Adicionar. Porm, em um aplicativo onde existam mais componentes e rotinas, um
cadastro de produtos por exemplo, o cdigo clssico do Android acaba se tornando complexo, demorado e
repetitivo.
So necessrias as declaraes de variveis e na criao da Activity, necessrio vincular cada uma com o
componente correspondente no arquivo XML, um processo muito sujeito a erros, pois caso no seja
vinculado corretamente, a utilizao do componente pode gerar erros e at finalizar a aplicao.
Para desenvolver o mtodo que captura um evento de click de boto, mesmo sem executar nenhuma funo,
precisamos de pelo menos mais cinco linhas de cdigo. Em uma tela com vrios botes, ser necessria uma
grande quantidade de cdigo a mais.
Quando se trata de processos separados (Thread de Background) que precisam interagir com a tela, a
complexidade se torna ainda maior. necessrio um tempo considervel para que o programador consiga
entender plenamente o funcionamento desta tarefa e consiga desenvolver algo utilizando-a, o que torna o
desenvolvimento ainda mais difcil para desenvolvedores menos experientes.
Consequentemente, a manuteno deste cdigo tende a se tornar complicada, principalmente em alteraes
de grande impacto ou correo de erros. Uma vez desenvolvido o aplicativo no modo clssico do Android, o
prximo passo o desenvolvimento utilizando o Android Annotations.
Android Annotations
A biblioteca Android Annotations gratuita e open source. Ela foi desenvolvida pelo Francs Pierre-Yves
Ricau, em 2010, com o objetivo de simplificar o desenvolvimento de cdigos na plataforma Android. A
Figura 5 apresenta a pgina principal da biblioteca.
8


Figura 5. Pgina principal da biblioteca.
Essa biblioteca realiza a gerao de cdigo em tempo de compilao por meio do processamento de
anotaes, similar aos Annotations utilizados pelo Java tradicional. Esta biblioteca permite acelerar o
desenvolvimento, mantendo o cdigo limpo, facilitando a manuteno.
Entre os recursos previstos por esta biblioteca, est a utilizao de webservices REST, injeo de
dependncias (views, extras, etc.), facilita o trabalho com Threads que executam em background, alm da UI
Thread (User Interface Thread) para interagir com a interface visual, etc.
A biblioteca gera um cdigo final, este que compilado e enviado para o device Android. Assim, na
Activity MainActivity.java, por exemplo, so utilizadas todas as anotaes desejadas pelo programador,
entretanto, quando salvo, gerado um novo arquivo dentro da pasta .apt_generated, este com um sufixo _
(underline). Para o MainActivity.java, gerado o arquivo MainActivity_.java, este sem as annotations, j
pronto para compilar e ser executado no emulador.
Assim, importante mudar no AndroidManifest.xml do projeto o nome da Activity, o qual deve finalizar
com um _ (underline).
Outra caracterstica que todos os recursos que recebem anotaes no aplicativo, ou devem ser pblicos, ou
protegidos, nunca podem ser privados, justamente pelo fato do cdigo ser gerado em tempo de codificao e
em uma classe diferente, caso contrrio a biblioteca no ir conseguir acessar tal recurso.
Preparando o Android Annotations no Eclipse
O primeiro passo para a utilizao do Android Annotations baixar a biblioteca, a qual est disponvel
dentro do link Documentation Download. At o fechamento deste artigo, a ltima verso do Android
Annotations a 3.0.1. A pasta baixada a androidannotations-bundle-3.0.1.
Para configurar o AndroidAnnotations no Eclipse, basta seguir os seguintes passos:
1. Clique com o boto direito sobre seu projeto, escolhendo a opo Properties;
9

2. Acesse a opo Java Compiler e observe se a opo Compiler Compliance Level est valorizada com
1.6, caso contrrio, o processador no poder ativar o Android Annotation;
3. Acesse a opo Java Compiler Annotation Processing e escolha a opo Enable anotation
processing. Isto habilitar o uso de annotation no projeto;
4. Acesse a opo Java Compiler Annotation Processing Factory Path e adicione o arquivo Jar Externo
androidannotations-3.0.1.jar. Em seguida, acesse a opo Java Build Path Libraries e adicione o arquivo
Jar Externo androidannotations-api-3.0.1.jar. Com isso, a biblioteca com o conjunto de facilidades
disponibilizadas pelo annotations ser acrescentada ao projeto;
5. Confirme as configuraes.
A Figura 6 apresenta uma das telas de configurao do Eclipse para utilizar o Android Annotations.

Figura 6. Tela para configurao do Android Annotations.
Por fim, aps colocar o Android Annotations nas configuraes do Eclipse, o prximo passo mudar dentro
do AndroidManifest.xml o nome da classe que faz uso das anotaes, no nosso caso, mudar de MainActivity
para MainActivity_ (terminando com underline), conforme Listagem 3, linha 3. Em seguida, partiremos
para as mudanas no cdigo fonte.
Listagem 3. Mudana no arquivo AndroidManifest.xml.
1. android:theme=@style/AppTheme>
10

2. <activity
3. android:name=br.edu.utfpr.aplicaticoexemplo.MainActivity_
4. android:label=@string/app_name >
5. <intent-filter>
6. <action andoid:name=android.intent.action.MAIN />
7. <category andoid:name=android.intent.category.LAUNCHER />
8. </intent-filter>
9. </activity>
Desenvolvimento Adequado
Basicamente o nico arquivo que iremos modificar considerando todo o projeto o MainActivity.java,
conforme Listagem 4. Neste estudo de caso, este o nico arquivo por que toda a lgica da aplicao foi
desenvolvida nele.
Listagem 4. MainActivity.java Com androidannotations
1. package br.edu.utfpr.aplicativoexemplo;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5.
6. import org.androidannotations.annotations.AfterViews;
7. import org.androidannotations.annotations.Background;
8. import org.androidannotations.annotations.Click;
9. import org.androidannotations.annotations.EActivity;
10.import org.androidannotations.annotations.Fullscreen;
11.import org.androidannotations.annotations.UiThread;
12.import org.androidannotations.annotations.ViewById;
13.
14.import android.app.Activity;
15.import android.app.ProgressDialog;
16.import android.content.Intent;
17.import android.util.Log;
18.import android.widget.ArrayAdapter;
19.import android.widget.Button;
20.import android.widget.ListView;
21.import android.widget.Toast;
22.
23.@Fullscreen
24.@EActivity(R.layout.activity_main)
25.public class MainActivity extends Activity {
26.
27. @ViewById
28. protected ListView lvItem;
29. @ViewById
30. protected Button btAdicionar;
31. private ProgressDialog progress;
32. private List<String> itens;
33.
34. @AfterViews
35. protected void create() {
36. progress = new ProgressDialog(this);
37. progress.setCancelable(false);
38. progress.setProgressStyle(ProgressDialog.STYLE_SPINNER);
39. progress.setMessage("Carregando os itens");
40.
41. itens = new ArrayList<String>();
42.
43. progress.show();
44. carregarItens();
45. }
46.
11

47. @Click(R.id.btAdicionar)
48. protected void btAdicionarClick() {
49. Intent adicionar = new Intent(MainActivity.this,
50. AdicionarActivity.class);
51. startActivity(adicionar);
52. }
53.
54. @Background
55. protected void carregarItens() {
56. try {
57. Thread.sleep(5000);
58.
59. itens.add("Item exemplo 1");
60. itens.add("Item exemplo 2");
61. itens.add("Item exemplo 3");
62.
63. } catch (InterruptedException e) {
64. Log.i("Erro", e.getMessage());
65. exibeErro();
66. }
67.
68. exibeItens();
69. }
70.
71. @UiThread
72. protected void exibeItens() {
73. lvItem.setAdapter(new ArrayAdapter<String>(MainActivity.this,
74. android.R.layout.simple_list_item_1, itens));
75. progress.dismiss();
76. }
77.
78. @UiThread
79. protected void exibeErro() {
80. progress.dismiss();
81. Toast.makeText(MainActivity.this, "Erro ao carregar os itens",
82. Toast.LENGTH_LONG).show();
83. }
84.
85.}
Como pode ser observado, as mudanas so pequenas no programa, mas significativas no ponto de vista de
produtividade.
A primeira mudana so os imports referentes s classes utilizadas nas annotations (linhas 06 a 12).
Em seguida, antes da declarao do Activity, utilizada a annotation @Fullscreen (linha 13) para informar
que o aplicativo executar em tela cheia, e @EActivity(R.layout.activity_main), para informar quem ser a
interface grfica do Activity.
Na sequncia, antes da declarao de cada componente visual, a annotation @ViewById adicionada, assim
como os componentes devem ser declarados como protected, e no mais private.
Na linha 35 criado o mtodo create(), aps a annotation @AfterView. Este mtodo ir receber os mtodos
executados antes da apresentao da tela do aplicativo.
Para tratar o clique de um boto, no lugar de utilizar listener, foi criado o mtodo carregarItens() linha 48,
este aps o annotations @Click(R.id.btAdicionar), o qual j vincular o evento de clique ao boto
btAdicionar.
12

O mtodo executado em uma thread, em background, foi codificado nesta nova abordagem em
carregarItens() linha 55, este aps a annotations @Background. Isto far com que seu processamento seja
executada em paralelo ao incio do aplicativo. Este mtodo chamado pelo create(), na linha 44.
Por fim, os mtodos exibeItens() linha 72, e exibeErro() linha 79, apresentam mudanas na interface
grfica do dispositivo, por isso a annotation @UiThread.
Entendendo o porqu desta ser a melhor soluo
No aplicativo desenvolvido utilizando as anotaes, temos um cdigo muito mais limpo e fcil de entender,
com uma queda considervel na complexidade de desenvolvimento se comparado com o modo clssico.
Na declarao das variveis, j podemos vincular o componente do arquivo XML da tela apenas com a
anotao @ViewById. Isso garante que o componente ser corretamente inicializado e evita erros j no
incio do cdigo.
Um click de boto pode ser feito em apenas duas linhas de cdigo (linhas 49 e 51 da Listagem 4), e de uma
forma simples, visto que anotando com @Click possvel nomear o mtodo como o programador preferir.
Isto facilita a manuteno e utilizao deste posteriormente, diferente do cdigo clssico, onde necessrio
implementar o mtodo padro do Android.
Talvez um dos maiores ganhos de produtividade no aplicativo desenvolvido utilizando anotaes est no
processamento paralelo e na interao com a tela. Enquanto no modo clssico temos a necessidade de criar
uma subclasse estendendo de AssyncTask (linha 60 da Listagem 2), informando os parmetros que sero
referenciados nos trs mtodos necessrios para implementar a tarefa assncrona e a interao com a tela, no
cdigo com anotao precisamos apenas criar um mtodo qualquer sem retorno e o anotar com
@Background para o processo assncrono, e @UIThread para as interaes com a tela (linhas 54, 71 e 78 da
Listagem 4).
Com a biblioteca Android Annotations o ganho em produtividade notvel, tanto no desenvolvimento
quando na manuteno. Mais importante que reduzir o nmero de linhas, tornar o cdigo mais simples.
Tudo isso, com uma configurao facilitada e sem impactar na performance do aplicativo, pois o
processamento das anotaes feito em tempo de compilao.