[ VISÃO GERAL] Android – AndroidAnnotations

Mudando um pouco a linha que estava seguindo nos meus posts anteriores sobre Android, que apresentei uma overview e um tutorial de configuração do ambiente para a library Action Bar Sherlock e a base de dados db4o, neste post vou apresentar de forma simples vantagens e desvantagens da utilização do AndroidAnnotations e uma comparação entre as duas abordagens.

AndroindAnnotationsAndroidAnnotations(AA) é uma biblioteca gratuita e opensource desenvolvida por Pierre-Yves Ricau  e que possui em sua essência a idéia de simplificar o seu código, visando facilitar o desenvolvimento e melhorar a manutenibilidade.

E como ele faz isso? Adicionando um passo a mais no processamento das Annotations em tempo de compilação.
Não sabe o que são Annotations? Então você realmente deveria ler sobre, e poderia começar por aqui.

Ela pode ser utilizada em conjunto com libraries como: ActionBar Sherlock que implementa UI Pattern compatível com as diferentes versões do Android, GreenDroid, que visa adicionar mais consistência na View de suas aplicações e o RoboGuice que eu ainda não domino o total entendimento a respeito.

-Vantagem e Desvantagem
–Vantagem
A principal vantagem é o syntax sugar que ela traz para o desenvolvimento, agilizando o processo, a seguir alguns pontos que são aperfeiçoados pela library;

- Injeção de views e resources;
- Utilização de webservices REST;
- Trabalhar com Threads e a UI Thread;
- Binding de eventos.

–Desvantagem
Para desenvolvedores que estão começando com Android, acredito não ser indicado iniciar seus estudos com essa library, pois apesar de agilizar o desenvolvimento, a forma de trabalhar com componentes e threads por exemplo é totalmente alterada. Se você for iniciante, aprenda a desenvolver sem essa library e só então comece a utilizar, caso contrário seu entendimento do funcionamento da plataforma ficará comprometido.

-Comparação Desenvolvimento normal x Desenvolvimento com AA
A seguir apresentarei uma breve comparação.

Considere o seguinte arquivo xml com o nome ‘meu_layout’, o qual utilizarei mais tarde.

codigo_layout

- Preenchendo uma Activity com um layout
Basicamente para apresentar o ‘meu_layout’ em uma Activity você precisa sobreescrever o método onCreate e então informar qual o layout referente a tela.

 public class MyClass extends Activity {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.meu_layout);
 }

}

- Preenchendo uma Activity com um layout utilizando o AA
Para preencher a tela com o ‘meu_layout’ você necessita simplesmente anotar a classe com a Annotations @EActivity e apontar o layout.

@EActivity(R.layout.meu_layout)
public class MyClass extends Activity {

}

- Obtendo a referência dos componentes do layout atual
Para conseguir a referência de um EditText por exemplo é necessário encontrar a View pelo Id e em seguida efetuar um cast para o tipo do componente.

 public class MyClass extends Activity {

 private EditText edit;
 private Button button;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.meu_layout);

  edit = (EditText) findViewById(R.id.edit);
  button = (Button) findViewById(R.id.button);
 }
}

- Obtendo a referência dos componentes do layout atual com AA
Para obter a referência com é necessário somente anotar o atributo da classe com @ViewById , nesse case o nome do seu atributo necessariamente deve ser igual ao Id presente no xml.

 @EActivity(R.layout.meu_layout)
 public class MyClass extends Activity {

 @ViewById
 private EditText edit;

 @ViewById
 private Button button;

 }

Aqui temos outro ponto de melhoria, em tempo de compilação a IDE não identifica se o casting está correto o que pode ocasionar um erro em execução, utilizando o AA isso não acontece, pois esse cast é realizado internamente pelo AA.

- Trabalhando com threads em background e atualizando a tela.

Para rodar threads com processamentos que são lentos e ou trabalham com banco de dados e comunicações com a internet e em seguida atualizar a tela, você precisa de uma classe asynctask. Para dar o update na tela você precisa de um handler que faça isso para você, pois o Android nãp permite que você acesse a view por threads secundárias.

public class MyClass extends Activity {

 private EditText edit;
 private Button button;
 private Handler handler;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.meu_layout);

  edit = (EditText) findViewById(R.id.edit);
  button = (Button) findViewById(R.id.button);
  button.setOnclickListener(<code>new Button.OnClickListener() { 
        public void onClick(View v) {  
         new AtualizarTela().start();
        } 
  });</code>
  handler = new Handler() {
         @Override
          public void handleMessage(Message msg) {             
            updateUI();
  }};   
}

public void updateUI(){
   //faça algo na tela
}
 private class AtualizarTela extends AsyncTask&lt;Void, Void, Void&gt; { 

  @Override
  protected Void doInBackground(String... params) {
     for( int i = 0 ; i &lt;=100; i++){
         Thread.sleep(5000);
         handler.sendEmptyMessage();
     } 
  }
 }

- Trabalhando com threads em background e atualizando a tela com AA.

Para realizar a mesma tarefa apresentada anteriormente pouco código é necessário se compararmos as duas abordagens. A anotação @Background realiza todo o trabalho transformando o método em uma Thread secundária, a anotação @UiThread se chamada de uma thread secundária será executada na UiThread, assim dispensando a implementação do handler.

@EActivity(R.layout.meu_layout)
 public class MyClass extends Activity {

 @ViewById
 private EditText edit;

 @ViewById
 private Button button;

 @Click(R.id.button){
 public void click(View v){
   processar();
 }

 @Background
 public void processar(){
     for( int i = 0 ; i <=100; i++){
         Thread.sleep(5000);
         updateUI();
     } 
 }

 @UiThread
 public void updateUI(){
   //faça algo na tela
 }

}

 

Para visualizar um exemplo mais completo de comparação acesse esta página site.

-Conclusão

Como podemos perceber com alguns exemplos o AndroidAnnotations reduz consideravelmente a quantidade de código, mas não trata-se somente disso, e sim tambem da quantidade de código que posteriormente precisará ser lido em uma eventual manutenção.

A utilização deve acontecer quando o desenvolvedor já possuir um bom nível de conhecimento na plataforma, caso contrário os conhecimentos sobre o Android poderão ficar comprometidos.

Pretendo semana que vem estar disponibilizando um tutorial de como criar o ambiente para a utilização do AA em um projeto simples, para auxiliar pessoas que desejam trabalhar dessa forma, mas não tem conhecimento suficiente do inglês para ler a documentação oficial ( que é toda em inglês ).

4 thoughts on “[ VISÃO GERAL] Android – AndroidAnnotations

  1. Pingback: [ TUTORIAL ] Android – AndroidAnnotations como configurar o ambiente | Pedreiros do Software

    • Olá Hub.
      Na minha opinião o limite entre ser interessante o uso, está no conhecimento da forma de trabalho tradicional do Android. Como inflar as views, como criar fragmentos e etc…

      Nada impede de um developer começar o o android annotations, a unica questão é que pela internet e na empresas boa parte não irá utilizar o android annotations, levando a dificuldades que não existiriam..

      Se você se sente seguro no conhecimento, vai em frente, só fique ciente de que você estará “preso” ao estilo do android annotations nesse projeto, como qualquer framework que você possa utilizar.

Leave a Reply

Your email address will not be published. Required fields are marked *

*

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>