Umas das coisas que eu acho mais interessante quando estou desenvolvendo para Adobe AIR é a facilidade de realizar as atualizações da aplicação, é muito simples e fácil de implementar uma maneira automatica para as atualizações. Na verdade a implementação já existe, só é preciso saber como utilizar.
Neste post vou falar um pouco sobre o framework de update das aplicações air e como tirar proveito disso com um processo deployment também automatico utilizando ANT para compilar o projeto e Hudson para separar os ambientes e etc.
Air Update Framework – Atualização da aplicação
O framework de update do air trabalha basicamente com 3 coisas:
A classe ApplicationUpdaterUI e os arquivos de configurações update.xml e updateConfig.xml . Independente de como será feito o deployment da sua aplicação, o modo de atualização será sempre baseado nesta classe e nestes arquivos.
Você também pode utilizar esta classe atribuindo manualmente as propriedades que são lidas pelos arquivos de configuração, entretanto, com arquivo é possível alterar os valores depois que o AIR ja tiver sido compilado.
ApplicationUpdaterUI
Esta classe utiliza o arquivo de configuração updateConfig.xml para saber aonde procurar por uma atualização e informar em caso exista uma versão mais recente.
Esta classe precisa basicamente de 3 coisas.
- Setar a propriedade configurationFile com o arquivo updateConfig.xml
- Inicializar
- E verificar se há uma nova versao.
Segue abaixo um trecho de código com a utilização:
|
1
2 3 4 5 6 7 8 9 10 11 |
public static function checkNow(updateConfigFile:File):void
{ updater.configurationFile = updateConfigFile; updater.addEventListener(UpdateEvent.INITIALIZED, updateInitializeHandler); updater.initialize(); } private static function updateInitializeHandler(event:UpdateEvent):void |
No projeto que irei disponibilizar no final do post eu estou utilizando a classe VersionManager criada aqui na DClick para facilitar um pouco essa parte de configurar e inicializar o updater 
updateConfig.xml
Dentro do arquivo updateConfig.xml está todas as configurações de como a verificação de novas atualizações serão feitas. A classe ApplicationUpdaterUI lê estas informações durante a inicialização.
update.xml
Este arquivo contem a informação de qual é a versão atual do sistema e onde baixa-la. O update framework compara a versão do software que está sendo executada ( token <version> dentro do xml que descreve a aplicação air ) e caso for diferente da que esta no update.xml ele irá tentar fazer atualização para a nova versão.
ANT Task – Compilação através de linha de comando
Agora que agente ja viu como funciona o sistema para atualização de versão dos aplicativos AIR, podemos podemos deixar o processo de distribuição ainda mais rapido. Vamos ver como gerar a nova versão pelo plugin do flex e depois como gerar utilizando um script ANT
O plugin do flex possibilida fazer o export do projeto para o arquivo .air, basta clicar em project/export release build (imagem abaixo).
Entretanto deste modo cabe a você antes de executar o export configurar qual será a nova versão do aplicativo, e para qual ambiente ( producao/teste/cliente/etc ) você esta compilando esta nova versão.
Em um projeto desenvolvido com integração continua com o cliente, onde varias versões são compiladas durante o desenvolvimento, fazer o build da aplicação não é a melhor escolha.
Uma alternativa é criar um script ANT para buildar o projeto, com ele é possível buildar o projeto e a cada build alterar a versão do aplicativo, deste modo sem muito esforço você tem uma maneira mais prática para gerar as versões da aplicação. O esforço fica em criar o script a primeira vez porque dependendo do tamanho do projeto ( dependencia entre outros projetos, etc ) o script pode ficar grande e complexo.
No final do post vou deixar um link para um projeto no github, a ideia é que este projeto funcione como um template básico para quando for desenvolver um app em air, pois ele ja define a estrutura de pastas build/ambiente e também um script ANT padrao para buildar o projeto de acordo com cada ambiente que for necessário. O script esta todo comentado, de modo que é possível enter cada passo que esta sendo feito.
Como funciona o ANT para o Flex/Air?
O script é dividido em targets ( passos ) que são executados numa ordem definida pelo criador.
Por ex: Os passos básicos para gerar o .air são
- Compilar o projeto e gerar o swf.
- Gerar o instalador .air a partir do swf.
Compilação do SWF:
Para compilar o projeto e gerar o swf o script ANT utiliza um jar chamado flexTasks.jar. Primeiro é necessário incluir este jar dentro do script atráves da tag <taskdef /> do ant ( veja abaixo ):
Depois de incluir o jar como recurso é possível compilar o projeto utilizando a tag
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
<mxmlc file=“${air.src}/${air.app}.mxml” output=“${temp.dir}/${air.app}.swf” actionscript-file-encoding=“UTF-8″
keep-generated-actionscript=“false” incremental=“false” benchmark=“true” locale=“pt_BR” debug=“false” configname=“air” target-player=“10.0.0″ services=“${temp.dir}/${services.file.name}” context-root=“{context.root}”> <license product=“flexbuilder3″ serial-number=“xxxx-xxxx-xxxx-xxxx-xxxx-xxxx” /> <default-size height=“768″ width=“1024″ /> <source-path path-element=“${air.src}” />
<compiler.library-path dir=“${air.libs}” append=“true”> </mxmlc> |
Este exemplo foi extraido do script ANT que está no projeto template. Para ver mais detalhes sobre como utilizar a tag
Gerando o .AIR
Uma vez que você ja compilou o projeto e ja gerou o .swf, para gerar o .air você irá utilizar o jar .adt ( Adobe Developer Tool ). Diferente do flexTask.jar, o adt nós não vamos incluir como recurso no script, vamos executa-lo através da tag
Veja abaixo um exemplo extraido do script que esta no projeto de template:
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<java jar=“${air.adt}” fork=“true” failonerror=“true”>
<arg value=“-package” /> <arg value=“-storetype” /> <arg value=“${air.storetype}” /> <arg value=“-storepass”/> <arg value=“${air.certpassword}”/> <arg value=“-keystore”/> <arg value=“${air.cert}”/> <arg value=“${air.installer}” /> <arg value=“${app.description.final}” /> <arg value=“-C” /> <arg value=“${temp.dir}” /> <arg value=“${air.app}.swf” /> <arg value=“-C” /> <arg value=“${temp.dir}” /> <arg value=“update” /> </java> |
Com o ADT é possível gerar o .air já autenticado com um certificado ou simplesmente gerar um arquivo .airi sem autenticação e depois em um outro passo autenticar este arquivo intermediario. Para ver mais detalhes dos argumentos que o ADT recebe como passa-los segue o link da adobe
Como alterar a versão da aplicação a cada build?
Apesar de nós já termos visto como é feita a compilação do swf e como é gerado o .air, ainda não vimos como alterar a versão da aplicação a cada build. Muito bem, no script que está no projeto template, isto é feito através da tag
Veja abaixo a sequencia de como isto é feito no script que esta no projeto template.
|
1
2 3 4 5 6 7 8 9 10 |
<!– Atualiza o contador do arquivo que é refenciado pela propriedade ‘build.number.file’ –>
<buildnumber file=“${build.number.file}” /><!– Gera o codigo final da nova versão –> <!– Gera o código da nova versão. Neste caso estamos concatenando o valor de ‘project.version’ ( default.properties ) <!– atualiza o token version do description final –> |
Nestes 3 passos nós atualizamos o numero da versão do ambiente que esta sendo compilado, montamos o codigo final da versão ( neste caso V1, V2, V3 ) e em seguida alteramos o node <version /> do xml que descreve a aplicação de <version>[version]</version> para <version>v1</version>.
Na próxima vez que rodar o script o token será alterado novamente de <version>[version]</version> para <version>v2</version>. E assim sussesivamente.
Utilizar o Hudson para buildar o projeto com o script ANT
Apesar de ja estar utilizando o ANT para buildar o projeto e o update framework para verificar atualizações, não é muito interessante que o desenvolvedor tenha que ficar rodando manualmente o script ant, e sendo responsável por compilar o ambiente correto e etc. Para fazer este trabalho nós vamos utilizar o hudson.
Com o hudson você pode configurar um job que irá rodar o script ANT de maneira automatica. Além disso, o hudson pode ser integrado com o repositório de código ( git, subversion, cvs, etc ). Portanto após todos os commits da versão serem feitos, basta executar o job do hudson que ele ira baixar todas as alterações no código e em seguida executar o ANT para gerar a nova versão.
No script ANT o parâmetro que indica para qual ambiente estamos rodando é fornecido pelo Hudson, deste modo, para cada ambiente vamos criar um job no hudson.
Abaixo segue um screencast passo a passo de como criar um novo job no hudson ja integrado com o projeto template que esta no github e disponível para download.
Para aqueles que quiserem ver mais detalhes sobre o Hudson, segue o link oficial.
Segue o url para o pessoal que quiser dar uma olhada nos fontes ou até mesmo baixar o projeto/template com essas configuracões de ANT e etc.
http://github.com/thiagofelix/Air-Atualiza–o-Automatica
