android annotations - ganhando produtividade no desenvolvimento android

5/21/2018 Android Annotations - Ganhando Produtividade No Desenvolvimento Android

1/12

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 aplicativodesenvolvido 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 outrascoisas, o cdigo acaba se tornando complexo, demorado e repetitivo. A segunda verso, do mesmoaplicativo, far uso do Android Annotation, o qual simplifica muito a codificao do sistema permitindo umaumento significativo de produtividade em seu desenvolvimento.

Alm disso, o cdigo gerado com o uso de Annotations mais fcil de ser mantido durante a evoluo dosoftware 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 Cri s Br itoe Evaldo Augusto Bianchi

Desenvolver aplicativos para dispositivos mveis, em especial para a plataforma Android, era um grandedesafio quando a plataforma foi lanada, com poucos recursos e um ambiente de desenvolvimento bastantelimitado.

Era necessrio digitar os cdigos em um editor de cdigo separado, acessar o prompt de comando do sistemaoperacional 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 odesenvolvimento 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 permitindorecursos de depurao, integrao de recursos com o emulador, possibilidade de gerenciar as AVD (AndroidVirtual 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 Androidna forma mais clssica de codificao, criando a interface grfica no arquivo XML, aps codificando aActivity (cdigo .java), fazendo todos os findViewById(), um para cada componente visual utilizado, almdos 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 odesenvolvimento 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
http://www.devmedia.com.br/autor/robison-cris-brito/159883http://www.devmedia.com.br/autor/robison-cris-brito/159883http://www.devmedia.com.br/autor/robison-cris-brito/159883http://www.devmedia.com.br/autor/robison-cris-brito/159883


2/12

2

Para testar e demonstrar alguns recursos do Android Annotations, vamos desenvolver inicialmente umaplicativo 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, recursosbsicos como preparao do ambiente de desenvolvimento (instalao do eclipse, instalao e configuraodo 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 processamentoespecfico ser realizado nesta segunda tela.

As interfaces grficas tero o nome de activity_main.xml e activity_adicionar.xml, e as classesrespectivamente 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 olayout linear (linha 1), um boto (linha 6) e uma lista (linha 12).

Listagem 1. activity_main.xmlCdigo da interface principal.


3/12

3

1. 5.6. 11.12. 18.19.

Os cdigos das linhas 7 e 13 representam o identificador do componente que ser utilizado na classeMainActivity.java, cujo cdigo est representado, na forma clssica de desenvolvimento Android, conformeListagem 2.

Listagem 2.MainActivity.javaClasse 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. @Override28. 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/12

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. @Override52. 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. @Override63. protected void onPreExecute() {64. progress.show();65. }66.67. @Override68. 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. @Override85. 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 doisprimeiros componentes de tela e o terceiro um componente dinmico, que representar uma barra deprogresso.


5/12

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 classepai (linha 29). As linhas 31 a 33 so responsveis por deixar o aplicativo em tela cheia, sem as barras dettulo, 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 enquantosupostamente 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 elementosapresentados no ListView.

Duas linhas importantes para o aplicativo proposto so as 47 e 48, responsveis por executar uma Thread emparalelo, responsvel por carregar os itens no ListView. A classe CarregarItens apresentada com detalhes apartir da linha 60.

O processamento do boto adicionar realizado das linhas 50 a 57, e sua funo simplesmente criar umIntent (linha 53) para chamar a Activity AdicionarActivity.java, esta corresponde segunda janela doaplicativo.

A linha 60 declara uma nova Thread, esta chamada de CarregarItens. Esta classe herda funcionalidades deAssyncTask, 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() eonPostExecute().

O mtodo onPreExecute()linha 63 responsvel pelo cdigo antes da execuo da tarefa assncrona. Noexemplo, 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). Estalgica 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 oselementos adicionados no ArrayList ao componente ListView, utilizando para isso um ArrayAdapter (linha87). Por fim, o progressBar retirado da tela (linha 88).

Assim, ao executar o aplicativo, a tela da Figura 2 apresentada para o usurio, permanecendo cincosegundos na tela.


6/12

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/12

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 telaao pressionar um boto Adicionar. Porm, em um aplicativo onde existam mais componentes e rotinas, umcadastro de produtos por exemplo, o cdigo clssico do Android acaba se tornando complexo, demorado erepetitivo.

So necessrias as declaraes de variveis e na criao da Activity, necessrio vincular cada uma com ocomponente correspondente no arquivo XML, um processo muito sujeito a erros, pois caso no sejavinculado 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 umagrande quantidade de cdigo a mais.

Quando se trata de processos separados (Thread de Background) que precisam interagir com a tela, acomplexidade 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 odesenvolvimento ainda mais difcil para desenvolvedores menos experientes.

Consequentemente, a manuteno deste cdigo tende a se tornar complicada, principalmente em alteraesde 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-YvesRicau, em 2010, com o objetivo de simplificar o desenvolvimento de cdigos na plataforma Android. AFigura 5apresenta a pgina principal da biblioteca.


8/12

8

Figura 5.Pgina principal da biblioteca.

Essa biblioteca realiza a gerao de cdigo em tempo de compilao por meio do processamento deanotaes, similar aos Annotations utilizados pelo Java tradicional. Esta biblioteca permite acelerar odesenvolvimento, mantendo o cdigo limpo, facilitando a manuteno.

Entre os recursos previstos por esta biblioteca, est a utilizao de webservices REST, injeo dedependncias (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, naActivity 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 finalizarcom um _ (underline).

Outra caracterstica que todos os recursos que recebem anotaes no aplicativo, ou devem ser pblicos, ouprotegidos, nunca podem ser privados, justamente pelo fato do cdigo ser gerado em tempo de codificao eem 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 disponveldentro do link Documentation Download. At o fechamento deste artigo, a ltima verso do AndroidAnnotations 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/12

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 anotationprocessing. Isto habilitar o uso de annotation no projeto;

4. Acesse a opo Java Compiler Annotation ProcessingFactory Path e adicione o arquivo Jar Externoandroidannotations-3.0.1.jar. Em seguida, acesse a opo Java Build Path Libraries e adicione o arquivoJar Externo androidannotations-api-3.0.1.jar. Com isso, a biblioteca com o conjunto de facilidadesdisponibilizadas pelo annotations ser acrescentada ao projeto;

5. Confirme as configuraes.

A Figura 6apresenta 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 dentrodo 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, partiremospara as mudanas no cdigo fonte.

Listagem 3. Mudana no arquivo AndroidManifest.xml.

1. android:theme=@style/AppTheme>


10/12

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 foidesenvolvida nele.

Listagem 4. MainActivity.javaCom 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.@Fullscreen24.@EActivity(R.layout.activity_main)25.public class MainActivity extends Activity {26.27. @ViewById28. protected ListView lvItem;29. @ViewById30. protected Button btAdicionar;31. private ProgressDialog progress;32. private List itens;33.34. @AfterViews35. 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/12

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. @Background55. 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. @UiThread72. 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. @UiThread79. 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 deprodutividade.

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 informarque 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, assimcomo 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 mtodosexecutados 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/12

12

O mtodo executado em uma thread, em background, foi codificado nesta nova abordagem emcarregarItens()linha 55, este aps a annotations @Background. Isto far com que seu processamento sejaexecutada 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 interfacegrfica 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 aanotao @ViewById. Isso garante que o componente ser corretamente inicializado e evita erros j noincio do cdigo.

Um click de boto pode ser feito em apenas duas linhas de cdigo (linhas 49 e 51 da Listagem 4), e de umaforma 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 necessrioimplementar o mtodo padro do Android.

Talvez um dos maiores ganhos de produtividade no aplicativo desenvolvido utilizando anotaes est noprocessamento paralelo e na interao com a tela. Enquanto no modo clssico temos a necessidade de criaruma subclasse estendendo de AssyncTask (linha 60 da Listagem 2), informando os parmetros que seroreferenciados nos trs mtodos necessrios para implementar a tarefa assncrona e a interao com a tela, nocdigo 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 daListagem 4).

Com a biblioteca Android Annotations o ganho em produtividade notvel, tanto no desenvolvimentoquando 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.

android annotations - ganhando produtividade no desenvolvimento android

Documents