2010
13.04

Automatiser la production de vos applications Air

Par Frédéric             Catégorie: Developpement 

Dans un contexte industriel, il est important de pourvoir automatiser la production d’une application. Il existe pour cela des outils tels que Maven qui permettent de gérer et d’automatiser les différentes phases du cycle de production tel que les tests, la compilation, le déploiement, la livraison… 

Les applications utilisant les technologies Adobe Flex/Air sont de plus en plus présentes dans l’entreprise et doivent elles aussi pouvoir être produites de façon industrielle. Depuis quelques années le plugin FlexMojos permet d’utiliser Maven facilement pour les applications Flex. Cependant son utilisation pour des applications Air est un peu plus difficile. Nous allons nous intéresser ici à ce dernier cas.


Organisation du projet maven

Nous allons créer un petit projet Maven que nous appellerons « simpleAirProject » utilisant le SDK 4 de Flex. 

Il sera découpé en deux modules :
  • simple-client : contiendra le code source de l’application et produira un fichier SWF
  • simple-air : packagera le SWC précédemment produit en application air



Production du fichier SWF

Nous nous intéressons ici au fichier pom.xml du projet simple-client. 

Rien d’exceptionnel si vous êtes familier avec la compilation d’application Flex avec FlexMojos. Les seules différences pour une application Air sont au niveau des dépendances.
Il faut :
  • Exclure « playerglobal » de « flex-framework » qui sera sinon en conflit avec  la version du « air-framework »
  • inclure le « air-framework »

XMLpom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

    <dependency>
      <groupId>com.adobe.flex.framework</groupId>
      <artifactId>flex-framework</artifactId>
      <type>pom</type>
      <exclusions>
        <exclusion>
          <groupId>com.adobe.flex.framework</groupId>
          <artifactId>playerglobal</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
 
    <dependency>
      <groupId>com.adobe.flex.framework</groupId>
      <artifactId>air-framework</artifactId>
      <type>pom</type>
    </dependency>


Création de l’application AIR

Nous nous intéressons ici au fichier pom.xml du projet simple-air.

C’est là que ça devient plus compliqué.  En effet, FlexMojos ne gère pas pour le moment le type de package Air. Nous allons donc utiliser un packaging de type POM et adapter le cycle Maven.

Les dépendances

 Nous avons deux dépendances :
  • Le SWC produit par le projet simple-client.
  • La librairie ADT qui permet de packager en AIR et également de générer des certificats afin de signer nos applications.

XMLpom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

  <dependencies>
 
    <!-- Flex ADT tool -->
    <dependency>
      <groupId>com.adobe.flex.compiler</groupId>
      <artifactId>adt</artifactId>
      <type>jar</type>
    </dependency>
 
      <!-- Project Dependencies -->
    <dependency>
      <groupId>com.piaction</groupId>
      <artifactId>simple-client</artifactId>
      <version>${project.version}</version>
      <type>swf</type>
    </dependency>
 
  </dependencies>

Il faut copier le SWC dans le répertoire de build durant la phase « process-ressource » pour l’utiliser lors de la phase de packaging.

XMLpom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

    <plugin>
        <artifactId>maven-dependency-plugin</artifactId>
        <executions>
          <execution>
            <id>unpack-air-assets</id>
            <goals>
              <goal>copy</goal>
            </goals>
            <phase>process-resources</phase>
            <configuration>
              <artifactItems>
                <artifactItem>
                  <groupId>${project.groupId}</groupId>
                  <artifactId>simple-client</artifactId>
                  <version>${project.version}</version>
                  <type>swf</type>
                  <overWrite>false</overWrite>
                  <outputDirectory>${air.build.dir}</outputDirectory>
                  <destFileName>${swf.name}</destFileName>
                </artifactItem>
              </artifactItems>
            </configuration>
          </execution>
        </executions>
      </plugin>


Les ressources

Nous avons besoin de deux ressources :

  • un fichier « application.xml » décrivant l’application Air : 
    Ce dernier est présent dans le répertoire ’src/main/resources’. Il contient des tokens qui seront remplacés automatiquement et prendront en compte le nom de l’application, la version et le nom du SWF à utiliser.
  • un certificat « .pfx », permettant de signer l’application Air. Il n’est pas fournit dans les sources. Il faudra placer celui qui vous aurez généré dans le répertoire ’src/main/resources’.

Pour générer le certificat, exécutez la commande suivante :

XMLView Code 
1
2

java -jar /pathToYourMavenRepository/com/adobe/flex/compiler/adt/4.0.0.14159/adt-4.0.0.14159.jar 
       -certificate -cn SelfSigned 1024-RSA certif.pfx votreMotDePasse

Ces ressources doivent également être copiées dans le répertoire de build pour être utilisées lors du « packaging ».  Nous faisons cela pendant la phase ‘process-resources’.

XMLpom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <executions>
          <execution>
            <id>air</id>
            <phase>process-resources</phase>
             <goals>
               <goal>copy-resources</goal>
             </goals>
             <configuration>
             <outputDirectory>${air.build.dir}</outputDirectory>
             <resources>
               <resource>
                 <directory>${basedir}/src/main/resources</directory>
                 <filtering>true</filtering>
                 <includes>
                   <include>**/*.xml</include>
                 </includes>
                </resource>
                <resource>
                 <directory>${basedir}/src/main/resources</directory>
                 <filtering>false</filtering>
                 <includes>
                   <include>**/*.pfx</include>
                 </includes>
                </resource>
               </resources>
             </configuration>
          </execution>
        </executions>
      </plugin>


Packager l’application AIR

Nous pouvons enfin passer à la phase de création du package Air.
Nous faisons donc ici appel à la librairie ADT.

XMLpom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

     <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <executions>
          <execution>
            <phase>package</phase>
              <goals>
              <goal>exec</goal>
              </goals>
          </execution>
        </executions>
        <configuration>
          <executable>java</executable>
          <workingDirectory>${air.build.dir}</workingDirectory>
          <arguments>
            <argument>-classpath</argument>
            <classpath/>
            <argument>com.adobe.air.ADT</argument>
            <argument>-package</argument>
            <argument>-storetype</argument>
            <argument>pkcs12</argument>
            <argument>-storepass</argument>
            <argument>yourPass</argument>
            <argument>-keystore</argument>
            <argument>cert.pfx</argument>
            <argument>-keypass</argument>
            <argument>yourPass</argument>
            <argument>${project.artifactId}.air</argument>
            <argument>application.xml</argument>
            <argument>${swf.name}</argument>
          </arguments>
        </configuration>
      </plugin>


Installation et déploiement

Pour finir nous configurons les phases ‘install’  et  ’deploy’ permettant ainsi la mise à disposition dans les entrepôts Maven :

XMLpom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

 <plugin>
       <artifactId>maven-install-plugin</artifactId>
        <executions>
         <execution>
          <id>install-air</id>
          <goals>
           <goal>install-file</goal>
          </goals>
          <phase>install</phase>
          <configuration>
           <file>${air.build.dir}/${project.artifactId}.air</file>
           <artifactId>${artifactId}</artifactId>
           <groupId>${groupId}</groupId>
           <version>${version}</version>
           <packaging>air</packaging>
           <generatePom>true</generatePom>
          </configuration>
         </execution>
        </executions>
      </plugin>
 
       <plugin>
       <artifactId>maven-deploy-plugin</artifactId>
        <executions>
         <execution>
          <id>deploy-air</id>
          <goals>
           <goal>deploy-file</goal>
          </goals>
          <phase>deploy</phase>
          <configuration>
           <repositoryId>${project.distributionManagementArtifactRepository.id}</repositoryId>
           <file>${air.build.dir}/${project.artifactId}.air</file>
           <url>${project.distributionManagementArtifactRepository.url}</url>
           <artifactId>${artifactId}</artifactId>
           <groupId>${groupId}</groupId>
           <version>${version}</version>
           <packaging>air</packaging>
           <uniqueVersion>${project.distributionManagementArtifactRepository.uniqueVersion}</uniqueVersion>
          </configuration>
         </execution>
        </executions>
      </plugin>


Critique de la solution proposée

Il est tout à fait possible de gérer la production d’une application Air en recourant à Maven ; même si cela se révèle quelque peu fastidieux à l’initialisation du projet. Quoi qu’il en soit nous espérons que FlexMojos intégrera bientôt directement cette fonctionnalité.



  • Twitter
  • LinkedIn
  • viadeo FR
  • Facebook
  • Google Buzz
  • Netvibes
  • Tumblr
  • del.icio.us
  • Digg


Aucun commentaire.

Ajouter votre commentaire

Votre commentaire