Simplificando e otimizando código com Android Annotations

Atualmente, desenvolver para Android já não é mais um “bicho de sete cabeças”. O que contribui muito para isso é o fato de as IDE utilizadas no desenvolvimento Android, como o Eclipse (defasado) e o Android Studio (IDE oficial para Android), proverem diversos recursos que ajudam na codificação e manutenção do projeto.

Recursos como geração automática do XML do layout e menu quando uma Activity é criada, exibição de um preview do layout do app que pode ser testado em diversos tamanhos de tela,  importação e gerenciamento de bibliotecas com o gradle (esse último é exclusivo do Android Studio) são muito úteis aos desenvolvedores.

Apesar de todo esse suporte prestado pelas IDE, o desenvolvimento para Android ainda é pouco eficiente no quesito de linhas de código. A maioria dos projetos, por mais simples que sejam, exigem muitas linhas de código distribuídas entre código Java e XML. Mesmo que o desenvolvedor seja organizado e programe de maneira eficiente, implementar uma AsyncTask, por exemplo, pode gerar um acréscimo indesejado de linhas de código extras.

No universo das bibliotecas Android, existem algumas que visam simplificar o código e facilitar a sua manutenção, tais como Scaloid e AndroidAnnotations. Neste post, irei focar na AndroidAnnotations, pois já usei em alguns projetos e achei simples de implantar e utilizar.

Como o nome sugere, o AndroidAnnotations nada mais é do que um framework que faz uso de anotações Java, as quais geram código em tempo de execução. Uma das principais características desse framework é a simplificação da manipulação da UI Thread e Threads em background. O AndroidAnnotations também faz uso do conceito de injeção de dependência, o qual pode ser observado no relacionamento entre Activity e seu layout XML (veremos mais a frente como isso funciona), por exemplo. Para fazer uso do AndroidAnnotations em seu projeto, o arquivo gradle (Android Studio) deve ficar da seguinte forma (comentei as linhas mais importantes):

Após configurar o gradle, o próximo passo é conhecermos as annotations que iremos usar em nosso projeto. Para não alongar muito o post, resolvi citar apenas as que usarei no aplicativo exemplo. Nesse aplicativo haverá uma Activity que terá uma ImageView onde será carregada uma imagem quando um Button for acionado. Dessa forma, as annotations a serem utilizadas serão as seguintes:

• @EActivity: Indica que uma Activity será suportada pela AndroidAnnotations. Seu parâmetro é o ID do layout que será associado à Activity.
• @AfterViews: Indica que o método deve ser chamado após o carregamento dos componentes gráficos.
• @ViewById: Indica que um campo da Activity deve ser associado ao componente gráfico correspondente no layout.
• @Click: Indica que o método deve ser chamado quando o componente vinculado a ele for clicado. Seu parâmetro é o ID do componente.
• @Background: Indica que o método, ao ser invocado, será executado em uma Thread diferente da UI Thread.
• @UiThread: Indica que o método, ao ser invocado, será executado na UI Thread.

Caso você queria conhecer outras annotations e suas descrições, acesse este link.

Agora que já conhecemos as annotations podemos iniciar a implementação do aplicativo exemplo. Para isso, o primeiro passo é criarmos a Activity. Lembrando que ela será antecedida pela annotation @EActivity vinculada ao nome do layout XML que queremos usar, ficando da seguinte forma:

É importante ressaltar que o fato de o layout XML já ter sido declarado na annotation torna desnecessário o uso do método setContentView() dentro do onCreate(). O código será gerado automaticamente quando o app for compilado.

Com a Activity definida, o próximo passo é definirmos os componentes gráficos que serão utilizados nela. O código abaixo mostra como isso pode ser feito utilizando as annotations.

Como é possível notar no código acima, a annotation @ViewById foi utilizada na declaração dos componentes gráficos da Activity. Desse modo, o método findViewById() não é mais necessário. É importante citar que caso o ID do componente no layout XML seja diferente do nome dado a ele na Activity, o ID deve ser passado como parâmetro na annotation @ViewById.

Uma vez que os componentes gráficos já foram declarados, é necessário associar a annotation @AfterViews ao primeiro método, no nosso caso loadViews(), que será executado pela Activity. Isso garante que os componentes gráficos só serão utilizados após terem passado pelo binding.

Em seguida, já é possível definir o método baixarImagem() que será executado quando o Button for clicado e associado a annotation @Click. No aplicativo exemplo, a ação executada será o download de uma imagem para ser exibida no ImageView.

Para realizar o download da imagem, definimos o método executarDownload() associado à annotation @Background. Essa associação garante que o método não será executado na UI Thread e não travará o app.

Por fim, criamos o método atualizaViews() associado à annotation @UiThread, o qual será executado na UI Thread e atualizará a ImageView com a imagem obtida. É importante ressaltar que os métodos associados à annotations podem receber parâmetros normalmente, como é o caso do atualizaViews().

A versão final do código da Activity pode ser vista abaixo:

Por fim, o último passo que devemos seguir antes de executar o app é alterar o AndroidMainfest do projeto para que ele utilize a Activity que será gerada pelo AndroidAnnotations. O procedimento é bem simples, basta acrescentar um underline após o nome da Activity como no trecho de código abaixo:

Agora o aplicativo pode ser executado normalmente.

Caso você deseje ver a implementação completa desse aplicativo exemplo, acesse o código fonte que está disponível no GitHub através deste link: Exemplo Annotations.

E ai gostou do AndroidAnnotations? Caso você tenha alguma dúvida ou quer complementar o post com alguma informação, deixe um comentário.