Artigo WebMobile 29 - Ant + Antenna com Java ME

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Veremos uma aplicação prática de reuso de código utilizando Ant e Antenna para customizar aplicações Java ME. Falaremos um pouco dessas tecnologias e suas configurações a fim de obtermos versões da mesma aplicação para vários aparelhos a partir de um único código-fonte. Por fim, mostraremos um exemplo de como construir uma aplicação utilizando essas ferramentas.

Atenção: esse artigo tem um vídeo complementar. Clique e assista!

[lead]De que trata o artigo:

Veremos uma aplicação prática de reuso de código utilizando Ant e Antenna para customizar aplicações Java ME. Falaremos um pouco dessas tecnologias e suas configurações a fim de obtermos versões da mesma aplicação para vários aparelhos a partir de um único código-fonte. Por fim, mostraremos um exemplo de como construir uma aplicação utilizando essas ferramentas.

Para que serve:

Pesquisas mostram que aplicações para dispositivos móveis ganham mais ou menos popularidade por conseguir atingir uma maior gama de modelos de celulares. No entanto, tais dispositivos apresentam diferentes configurações. Neste cenário, aquela aplicação que conseguir atingir esse objetivo com mais velocidade e menos tempo terá um diferencial competitivo fortíssimo frente ao mercado de software. Para alcançar esse objetivo mostraremos uma técnica que possibilita a customização das aplicações escritas em Java ME com o impacto mínimo em código e tempo.

Em que situação o tema útil:

Com o Ant e o Antenna é possível otimizar o processo de deploy de uma aplicação independente de ambiente. Através de um processo chamado de pré-processamento de código, podemos manter apenas um código-fonte e indicar quais trechos do código devem ser compilados de acordo com cada modelo/fabricante.

Autores: Nelson Glauber de Vasconcelos Leal, Jorge Cavalcanti Barbosa Fonsêca e Felipe Silva Ferraz[/lead]

Uma das tarefas mais árduas no desenvolvimento de software para dispositivos móveis é escrever código que, além de prezar pelo bom gerenciamento de memória possa prover portabilidade a uma grande diversidade de fabricantes e modelos de aparelhos para os quais se desenvolve. Tamanho de tela, quantidade e disponibilidade de teclas, formato de áudio e vídeo suportados são algumas das características que variam bastante entre fabricantes e modelos. Mas como escrever um código que esteja preparado para todos esses tipos de variações? A utilização da ferramenta Ant juntamente com o Antenna é uma saída para esse tipo de problema.

A maioria das empresas que trabalham com o desenvolvimento mobile recorre a esse “artifício” para facilitar o processo de entrega (deploy) e tornar o seu código reutilizável, visando atingir o maior número de dispositivos possível. A Figura 1 mostra um esquema de como funciona o processo de deploy de uma aplicação Java ME com Ant e Antenna.

Figura 1. Etapas do deploy de uma aplicação Java ME com Ant/Antenna.

Conforme podemos ver na figura, o Ant recebe um arquivo XML e, baseado nesse arquivo, várias ações podem ser executadas. Veremos cada uma dessas ações mais adiante no artigo.

[subtitulo]Termos e definições[/subtitulo]

Antes de continuarmos, vamos definir o que faz cada etapa do processo ilustrado na Figura 1:

· Pré-processar: realiza uma varredura do código-fonte antes da compilação, que permite incluir diretivas de pré-processamento em código Java, similares às diretivas de compilação usadas na linguagem C, que de uma maneira geral definem partes do código que devem ou não ser compiladas;

· Compilar: é o processo de gerar os bytecodes (arquivos *.class) Java usando um compilador como o javac;

· Gerar JAD: é a criação do arquivo JAD (Java Application Descriptor) da aplicação;

· Gerar JAR: empacota todos os bytecodes e os recursos da aplicação (imagens, sons, etc.) em um arquivo JAR (Java ARchive);

· Obfuscar: reduz o tamanho do JAR final, renomeando classes, atributos e métodos para nomes menores, dificultando o entendimento do código caso seja submetido à engenharia reversa. Além disso, este processo remove classes, métodos, atributos e variáveis não utilizadas;

· Pré-Verificar: A verificação dos bytecodes é feita em dois locais: na máquina do desenvolvedor e no aparelho. O processo de pré-verificação é realizado na máquina do desenvolvedor e consiste na inserção de anotações nas classes para reduzir o tempo e a memória necessários para realização da segunda etapa. Essas anotações são chamadas de “stack maps”, e melhoram o desempenho da execução de operações na pilha do interpretador. A segunda parte é realizada dentro do aparelho, onde os bytecodes são validados quanto a algum acesso indevido que viole a segurança da KVM (Kilobyte Virtual Machine).

[subtitulo]Ant[/subtitulo]

O Ant é uma ferramenta para automatização de scripts desenvolvida pela Apache Foundation. Ela é similar ao make (usado na compilação de programas escritos na linguagem C, por exemplo), mas escrita em Java e independente de plataforma. Baseia-se em tarefas a serem executadas e descritas em um arquivo XML. Esse XML, chamado de build file, normalmente é nomeado como build.xml, e assim o referenciaremos daqui para frente, é composto basicamente por quatro elementos:

· project: elemento raiz do build file, representa o projeto a ser executado pelo Ant;

· property: parâmetros que passam valores a serem utilizados nas tarefas. Servem como variáveis dentro do build.xml. Essas propriedades também podem ser carregadas a partir de arquivos .properties;

· target: bloco de tarefas a ser executado;

· task: tarefa a ser executada.

Cada target pode conter várias tasks, e essas estão mapeadas em tags XML que executam uma tarefa específica. A Listagem 1 mostra um exemplo simples de um build.xml para uma aplicação Java SE.

Listagem 1. Conteúdo do arquivo build.xml usando apenas Ant.

  1. <?xml version="1.0"?>
  2. <project name="OlaMundo" default="executar">
  3.   <property name="dirDestino" value="classes"/>
  4.   <property name="nomeDoJar" value="ola.jar"/>
  5.   <target name="limpar">
  6.      <delete dir="${dirDestino}"/>
  7.      <delete file="${nomeDoJar}"/>
  8.   </target>
  9.   <target name="compilar" depends="limpar">
  10.     <mkdir dir="${dirDestino}"/>
  11.     <javac srcdir="." destdir="${dirDestino}"/>
  12.  </target>
  13.  <target name="criaJar" depends="compilar">
  14.     <jar destfile="${nomeDoJar}">
  15.        <fileset dir="${dirDestino}" includes="**/*.class"/>
  16.        <manifest>
  17.            <attribute name="Main-Class" value="OlaMundo"/>
  18.        </manifest>
  19.     </jar>
  20.  </target>
  21.  <target name="executar" depends="criaJar">
  22.     <java jar="${nomeDoJar}" fork="true"/>
  23.  </target>
  24.</project>

O arquivo começa com a tag raiz <project>. Nela podemos colocar o nome do projeto e qual a tarefa padrão. Essa tarefa será executada caso não seja informada nenhuma tarefa ao executar o comando ant, como veremos mais adiante. Depois, definimos duas propriedades, uma para o nome do diretório onde ficarão os arquivos .class, e outra para informar o nome do JAR da aplicação.

O primeiro <target> é “limpar”, responsável por apagar o diretório de destino e remover o JAR gerado (caso existam). Fazemos isso com a task <delete>. Note que ela pode receber tanto um arquivo individual quanto um diretório.

O target “compilar” depends de “limpar”. Isso quer dizer que, quando quisermos executar “compilar”, o Ant executará primeiro ”limpar”. Se esta for finalizada com sucesso, “compilar” é automaticamente iniciada. Um target pode depender de outros, bastando informar essas dependências na ordem e separadas por vírgula. <mkdir> cria o diretório de destino do código compilado. Note que o nome do diretório é obtido através da propriedade que criamos anteriormente. Para obtermos o valor de uma propriedade, usamos a sintaxe ${nome_da_propriedade}. Logo em seguida usamos a task <javac>, que compila o código passando o diretório de origem e o de destino.

Para gerar o JAR da nossa aplicação, criamos o target “criaJar” que depende de “compilar” (que por sua vez depende de “limpar”). Nela, usamos a task <jar> passando o nome do arquivo e o local onde desejamos criá-lo. Dentro dessa tag devemos passar um conjunto de arquivos ("

A exibição deste artigo foi interrompida :(
Este post está disponível para assinantes MVP

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?