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.

5.

6.

11.

12.

18.

19.

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 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();

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 {

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(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.

5.

6.

7.

8.

9.

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 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();

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(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.