Etude des API Java pour la génération de code Flash

IPST-CNAM
39, allées Jules Guesde
BP 61517
31015 Toulouse cedex 6
CONSERVATOIRE NATIONAL DES ARTS ET METIERS
CENTRE REGIONAL DE TOULOUSE
EXAMEN PROBATOIRE
DU DIPLOME D’INGENIEUR CNAM
en
INFORMATIQUE
par
Nicolas Botet
Etude des API Java pour la génération
de code Flash
Date de la soutenance : novembre 2007
Membres du jury :
Président : Professeur Dewez
Examinateur : Professeur Hadj Batatia

Probatoire CNAM 2007 – Nicolas Botet
Index
I. Introduction ............................................................................................................................. 4
II. Flash ...................................................................................................................................... 5
A. Présentation ........................................................................................................................ 5
1. Introduction ..................................................................................................................... 5
2. Histoire ............................................................................................................................ 5
3. Pourquoi Flash ? .............................................................................................................. 7
4. Evolution de Flash .......................................................................................................... 8
B. Description technique ......................................................................................................... 9
1. Création d’un document SWF ......................................................................................... 9
2. Utilisation d’un document SWF ................................................................................... 11
3. Le fichier SWF .............................................................................................................. 13
4. Le langage Action Script ............................................................................................... 17
5. Fonctionnement du lecteur Flash .................................................................................. 19
III. La génération de code par les API JAVA .......................................................................... 21
A. Introduction ...................................................................................................................... 21
B. Les API ............................................................................................................................ 22
1. Metaas 0.7 API .............................................................................................................. 22
2. JavaSWF2 ..................................................................................................................... 27
3. Transfom SWF .............................................................................................................. 34
4. Translate AS1 ................................................................................................................ 39
5. JSwiff ............................................................................................................................ 46
C. Comparaison des différentes API ..................................................................................... 51
1. Mise à jour de l’API ...................................................................................................... 51
2. Utilisation en fonction de la version Flash .................................................................... 51
3. Les licences ................................................................................................................... 53
4. En résumé ...................................................................................................................... 53
IV. Conclusion ......................................................................................................................... 55
V. Bibliographie ....................................................................................................................... 56
Etude des API java pour la génération de code Flash - Page 2/59

Probatoire CNAM 2007 – Nicolas Botet
Table des illustrations
Illustration 1 : Les utilisations les plus courantes de Flash.........................................................6
Illustration 2 : Portabilité de Flash.............................................................................................7
Illustration 3 : Construction d’un fichier Flash à partir de Flash CS3.......................................9
Illustration 4 : Construction d’un fichier Flash à partir de Flex 2............................................10
Illustration 5 : Utilisation statique d’un fichier SWF...............................................................11
Illustration 6 : Utilisation dynamique d’un fichier SWF avec compilation.............................11
Illustration 7 : Utilisation dynamique d’un fichier SWF sans compilation..............................12
Illustration 8 : Tag à en-tête court (enregistrement de moins de 63 bytes)..............................14
Illustration 9 : Tag à en-tête long (enregistrement de 63 bytes ou plus)..................................14
Illustration 10 : Schéma représentant le modèle de programmation du lecteur Flash.............19
Illustration 11 : Fiche récapitulative de l’API Metaas 0.7.......................................................22
Illustration 12 : Exemple d’utilisation de l’API Metaas 0.7....................................................22
Illustration 13 : Illustration de l’exemple utilisant l’API Metaas 0.7......................................26
Illustration 14 : Fiche récapitulative de l’API JavaSWF2.......................................................27
Illustration 15 : Exemple d’utilisation de l’API JavaSWF2....................................................27
Illustration 16 : Illustration de l’exemple utilisant l’API JavaSWF2.......................................32
Illustration 17 : Fiche récapitulative de l’API Transform SWF...............................................34
Illustration 18 : Exemple d’utilisation de l’API Transform SWF............................................34
Illustration 19 : Résultat de l’exemple utilisant l’API Transform SWF..................................37
Illustration 20 : Illustration de l’exemple utilisant l’API Transform SWF..............................37
Illustration 21 : Fiche récapitulative de l’API Translate AS1..................................................39
Illustration 22 : Exemple d’utilisation de l’API Translate AS1...............................................39
Illustration 23 : Illustration de l’exemple utilisant l’API Translate AS1.................................44
Illustration 24 : Fiche récapitulative de l’API JSwiff..............................................................46
Illustration 25 : Exemple d’utilisation de l’API JSwiff...........................................................46
Illustration 26 : Création du fichier swf dans l’exemple utilisant l’API Transform SWF.......49
Illustration 27 : Résultat « tutorial.swf » dans l’exemple utilisant l’API Transform SWF.....49
Illustration 28 : Illustration de l’exemple utilisant l’API JSwiff.............................................50
Illustration 29 : Fiche récapitulative des API étudiées...........................................................54
Etude des API java pour la génération de code Flash - Page 3/59

Probatoire CNAM 2007 – Nicolas Botet
I.Introduction
Les technologies liées aux développements d’applications ne cessent d’évoluer. Hier nous
parlions d’applications client/serveur, aujourd’hui, nous parlons d’applications riches où l’on
retrouve une ergonomie proche des applications classiques bureautiques exécutées de façon
asynchrone sur le poste client.
Cette étude porte sur « l’étude des API java permettant la génération de code Flash ». Il existe
d’autres API, pour d’autres langages de programmation. Ce sujet est précis quant à la
technologie utilisée tout en restant vague, sur la finalité et le cadre de son application. En
effet, l’étude portera sur les API Java permettant la génération et l’utilisation de la technologie
Flash.
Flash permet l’affichage vectoriel et est destiné à l’utilisation du multimédia surtout autour
des technologies du web. Il est très utilisé pour développer des bandeaux publicitaires, des
jeux, des sites Internet ou bien des applications web. Cependant, le format du fichier reste
propriétaire même si il est ouvert et qu’une évolution se fasse ressentir notamment pour la
machine virtuelle de l’action script, donnée à la fondation Mozilla.
D’un autre côté, java, est un langage libre et portable. Il est très utilisé pour le développement
d’applications notamment client serveur. Une multitude d’API ont été développées pour java,
ce qui le rend plus puissant et lui permet d’évoluer. Un de ses inconvénients est la lourdeur de
son exécution notamment pour les applications client serveur. Posséder un ordinateur et un
réseau performant est recommandé. Le code compilé est ensuite exécuté sur la machine
virtuelle JAVA. Il existe différents moyens d’exécuter une application java : sur un serveur,
en local, par le biais d’une applet. Quoiqu’il en soit, l’installation de la machine virtuelle sera
nécessaire.
Les deux technologies étudiées nécessitent pour fonctionner un lecteur (plugin) ou une
machine virtuelle. Cependant, que ce soit Java ou Flash, ces environnements de
développements offrent aux développeurs une multitude de solutions afin de développer des
applications. Dans le cadre de ce sujet nous nous intéresserons aux développeurs JAVA qui
souhaitent publier dynamiquement ou non des animations Flash, permettant un fort potentiel
graphique, portable, sans utiliser d’applications Adobe mais en utilisant JAVA.
Dans un premier temps, nous ferons une présentation de la technologie Flash afin de mieux
appréhender la deuxième partie, qui est l’étude des API java.
Etude des API java pour la génération de code Flash - Page 4/59

Probatoire CNAM 2007 – Nicolas Botet
II.Flash
A.Présentation
1.Introduction
Le mot « Flash » peut avoir plusieurs définitions.
Il peut désigner :
un logiciel de programmation ( Adobe flash )
une machine virtuelle permettant de lire les fichiers flash
un fichier Flash dont l’extension est « SWF ».
Un fichier Flash est lisible par le biais d’un lecteur Flash qui se présente sous la forme d’un
plugin du navigateur Internet ou bien sous forme d’un programme à installer sur le système
d’exploitation. Le plugin est la forme la plus répandue.
2.Histoire
En 1996, la société Macromédia achète à la société « Future Wave » un logiciel d’animation
vectoriel qu’elle commercialisera sous le nom de Flash 1.0.
Au fil du temps, la version du logiciel Flash 1.0 a évolué, pour proposer des animations au
lancement de plus en plus rapide, la création du langage « Action Script », un lecteur
permettant la visualisation de fichier « SWF » sur des périphériques embarqués.
Le 3 décembre 2005, la société Adobe Systems achète Macromédia et tous ses produits.
Aujourd’hui, Adobe Systems propose :
Le runtime Flash (gratuit) : pour exécuter des contenus au format SWF au sein de
pages Web (approche RIA)
Le futur runtime Apollo (gratuit) : pour exécuter des contenus au format SWF à partir
d’une application embarquée (approche RDA)
L’environnement Flash CS3 (payant) : pour développer des contenus SWF statiques
L’environnement Flex Builder 2, basé sur Eclipse (payant) : pour développer des
contenus SWF dynamiques, en fonction du contexte utilisateur
Le Flex 2 SDK (gratuit) : pour générer les contenus SWF dynamiques à partir d’un
serveur
Le composant serveur Flex Charting 2 (payant) : pour générer des graphiques à la
volée
Le composant serveur Flex Data 2 services (payant) : pour l’intégration à des données
de type Back Office
Chacun de ces outils propose aux développeurs une solution de développement permettant la
réalisation d’une simple animation à une application complexe.
Etude des API java pour la génération de code Flash - Page 5/59