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
Probatoire CNAM 2007 – Nicolas Botet
Illustration 1 : Les utilisations les plus courantes de Flash
Etude des API java pour la génération de code Flash - Page 6/59
Probatoire CNAM 2007 – Nicolas Botet
3.Pourquoi Flash ?
La technologie Flash est très attrayante car elle permet de créer des animations web grâce à
l’utilisation du multimédia et la création d’application web offrant un design intéressant.
Cette utilisation du multimédia est permise grâce au lecteur flash, embarqué entre 70% et 97%
selon les sources 1 dans les navigateurs web, qui permet une lecture du fichier SWF.
L’utilisation de cette technologie présente les intérêts et les inconvénients suivants :
a)Avantages




Le lecteur Flash est léger.
Il permet le Streaming
Il est portable : le lecteur Flash Player 9 peut être installé sur différents systèmes
d’exploitation (Microsoft, Unix, Mac OS) et sur les browsers les plus courants
(Internet Explorer et Firefox). Grâce au lecteur Flash Lite 2.1, il permet également son
exécution sur des clients type PDA.
Le code exécuté est compilé : le code exécutable est un fichier binaire au format SWF
exécuté par le plugin (lecteur Flash). Ce procédé permet une plus grande efficacité lors
de l’exécution du fichier car :


Il est téléchargé intégralement avant d’être exécuté
Il n’a pas besoin d’être analysé par le browser (VS JavaScript)
Illustration 2 : Portabilité de Flash
b)Inconvénients




1
Installation d’un plugin
Sécurité car l’exécution du fichier se fait en local sur l’ordinateur
Référencement du site suite à une interprétation partielle par le navigateur
Le code source est propriétaire
Sources : Macromedia, NPD, Webhits
Etude des API java pour la génération de code Flash - Page 7/59
Probatoire CNAM 2007 – Nicolas Botet
4.Evolution de Flash
Flash, extrêmement populaire, propose une gamme complète de produits. A ce titre, Adobe
est concurrencé par les logiciels libres et par d’autres concurrents comme Microsoft.
Pour mieux se positionner, Adobe ouvre le code source de Flex sous licence MPL 1 et donne
également à la fondation Mozilla le code source de la machine virtuelle ActionScript 3
disponible sous trois licences : MPL, GPL, LGPL. Tout ceci afin de travailler avec Mozilla
pour faire évoluer plus vite la norme EcmaScript 2 tout en évitant la concurrence de Flex par
OpenLazlo.
Afin de ne pas perdre un certain monopole et une avance sur ses produits, Adobe va proposer
un nouvel environnement d’exécution orienté R.D.A3, Appolo ou A.I.R 4.
De ce fait, certains produits vont évoluer vers de nouvelles versions. C’est le cas pour Flex2
qui va évoluer vers Flex3 et une troisième version du lecteur Flash9 sera bientôt disponible.
Adobe pourra proposer un mélange de Flash, HTML et PDF au sein d'applications de bureau.
Les langages utilisés ne devraient pas changer (ActionScript3).
1
M.P.L. : Mozilla Public License
EcmaScript : langage de programmation de type script développé dans le cadre des travaux de l'ECMA
(javascript)
3
R.D.A. : Rich Desktop Application
4
A.I.R. : Adobe Integrated Runtime
2
Etude des API java pour la génération de code Flash - Page 8/59
Probatoire CNAM 2007 – Nicolas Botet
B.Description technique
1.Création d’un document SWF
a)La création d’un document SWF
Un document SWF peut être créé de plusieurs façons :


Par le biais d’un outil de développement (Flash CS3, Flex Builder 2)
Par la génération de code :
o Génération automatique SWF
o Compilation Action Script
Utilisation du logiciel Flash CS3
Dans le cadre d’un développement à l’aide du logiciel Flash CS3, à contrario de la génération
de code par le biais d’un langage de programmation, le développeur travaille sur un fichier
« .fla ».
Ce fichier contient 3 types d’informations :



Les objets multimédia : représente les différents objets comme les graphiques, le texte,
le son et la vidéo
Le scénario : indique à Flash quand faire apparaître les objets multimédia
Le code action script : code de programmation qui permet de proposer des interactions
avec les utilisateurs et de contrôler le comportement des documents Flash.
Illustration 3 : Construction d’un fichier Flash à partir de Flash CS3
Le fichier « .fla » sera compilé en Byte Code pour obtenir un fichier « .swf », qui sera lu par
un lecteur Flash.
Etude des API java pour la génération de code Flash - Page 9/59
Probatoire CNAM 2007 – Nicolas Botet
Utilisation du logiciel Flex 2
Dans le cadre d’un développement à l’aide de l’outil de développement Flex2, le développeur
utilisera du code Action Script et du code MXML 1.
Exemple de composantes nécessaires au développement par Flex :


Le code Action Script : code de programmation qui permet de proposer des
interactions avec les utilisateurs et de contrôler le comportement des documents Flash
Le code MXML : surcouche d’Action Script3 permettant d’utiliser des feuilles de
styles, des composants, du code au format AS3, etc
Illustration 4 : Construction d’un fichier Flash à partir de Flex 2
b)Les fichiers liés aux applications Flash








Les fichiers FLA : ils contiennent les informations de base sur les médias, le scénario
et les scripts d'un document Flash.
Les fichiers SWF : Fichiers affichés dans une page Web.
Les fichiers AS sont des fichiers ActionScript.
Les fichiers SWC contiennent les composants Flash réutilisables.
Les fichiers ASC servent à stocker le code ActionScript qui sera exécuté sur un
ordinateur exécutant Flash Communication Server.
Les fichiers JSFL sont des fichiers JavaScript qui permettent d'ajouter de nouvelles
fonctionnalités à l'outil de programmation Flash.
Les fichiers FLP sont des fichiers de projet Flash (Flash Professionnel uniquement).
Les fichiers MXML : permettant l’utilisation de composants.
Dans cette étude, nous nous consacrerons aux fichiers « SWF » et « AS ».
1
MXML : langage créé par Adobe/Macromédia basé sur le format texte XML
Etude des API java pour la génération de code Flash - Page 10/59
Probatoire CNAM 2007 – Nicolas Botet
2.Utilisation d’un document SWF
Le domaine d’utilisation de Flash est vaste, il va servir au publicitaire afin d’afficher une
publicité animée dans un site, créer des jeux, développer des applications clients serveur etc.
Nous allons pouvoir classer l’utilisation d’un document Flash dans deux catégories :


Utilisation statique : création d’un document SWF dont on ne modifiera pas le
comportement sans le recompiler (ex : encart publicitaire)
Utilisation dynamique : création d’un document SWF dont on modifiera le contenu
soit par compilation soit par l’utilisation d’une base de données ou d’un fichier
extérieur
Ensuite, nous allons nous intéresser aux différents moyens de modifier et d’utiliser un
document SWF. Le document SWF sera recompilé ou non :
Utilisation statique
Illustration 5 : Utilisation statique d’un fichier SWF
Utilisation dynamique

Compilation :
o Coté serveur, possibilité de générer des fichiers SWF
Illustration 6 : Utilisation dynamique d’un fichier SWF avec compilation
Etude des API java pour la génération de code Flash - Page 11/59
Probatoire CNAM 2007 – Nicolas Botet

Sans compilation :
o Le document sera modifié grâce à une base de données
o L’utilisation de fichiers extérieurs (AS, texte)
o Passage de variable au moment de son lancement dans le navigateur web
Illustration 7 : Utilisation dynamique d’un fichier SWF sans compilation
Etude des API java pour la génération de code Flash - Page 12/59
Probatoire CNAM 2007 – Nicolas Botet
3.Le fichier SWF
a)Présentation
Le fichier SWF (prononcé « swiff ») a été étudié pour distribuer des animations multimédia,
au sens large du terme, sur Internet.
Rendu de l’affichage : étudié principalement pour l’affichage, il gère l’anti-aliasing, un rendu
rapide de bitmap quelque soit le format de la couleur, des animations et des boutons
interactifs.
Extensible : grâce à son principe de tag, le fichier est évolutif et compatible avec des lecteurs
plus anciens.
Conçu pour le réseau : les fichiers peuvent être transmis sur un réseau lent et de mauvaise
qualité. Les fichiers sont très compressés et supportent le streaming
Simplicité : le format est simple pour que le lecteur soit petit et facilement portable. Le lecteur
dépend de très peu de fonctionnalités du système d’exploitation.
Indépendance : les fichiers peuvent être affichés sans aucune dépendance de ressources
externes.
Universalité : peut s’exécuter sur des moniteurs ayant une résolution et une vitesse de
rafraîchissement différentes. Le fichier pourra être exécuté sur une machine à faible potentiel
comme tirer le meilleur d’une machine très performante.
Rapidité : les fichiers ont été étudiés pour avoir un rendu d’une excellente qualité le plus
rapidement possible.
b)Concept de base
Un fichier Flash, dont l’extension est « SWF » et le type MIME 1 « application/x-shockwaveflash », contient plusieurs séquences de données délimitées par des tagues. Le fichier SWF est
un fichier binaire.
Chaque fichier commence par un tag « header » suivi par une séquence de tag décrivant
comment l’animation est affichée puis se termine par un tag « end ».
Le tag « header » identifie :






1
le type : 3 premiers bits
la version du fichier Flash : 4ième bit etc.
la longueur du fichier du fichier
la taille en TWIPS
le nombre de « frame » par seconde
le nombre total de « frame »
MIME : Multipurpose Internet Mail Extensions
Etude des API java pour la génération de code Flash - Page 13/59
Probatoire CNAM 2007 – Nicolas Botet
Apres le « Header », les tags suivants sont des séries de blocs de données. Chaque bloc à un
type de tag et une longueur
Field
Type
Commentaire
Tag
UB[10]
Tag id
Length
UB[6]
Longueur du tag
Illustration 8 : Tag à en-tête court (enregistrement de moins de 63 bytes)
Field
Type
Commentaire
Tag
UB[10]
Tag id
Long Header Flag
UB[6]
Always 0x3F
Length
UI32
Longueur du tag
Illustration 9 : Tag à en-tête long (enregistrement de 63 bytes ou plus)
(1)Type de tag
Il existe deux catégories de tag :


Tag de définition : ils sont utilisés pour décrire les formes, les images, les boutons, les
sons etc.
Tag de contrôle : ils sont utilisés pour créer des instances de formes, images, etc., puis
les afficher pour créer des animations dans le lecteur Flash.
(2)Ordre et streaming
Les tags de définitions doivent se trouver avant les tags de contrôle. L’ordre des tags de
contrôle définit l’ordre des animations. Ce système d’ordre, permet le streaming. Un tag ne
dépend que de celui qui est lu avant.
Etude des API java pour la génération de code Flash - Page 14/59
Probatoire CNAM 2007 – Nicolas Botet
(3)Identification et dictionnaire
Afin de supporter le streaming et le suivi entre deux tags, SWF utilise le principe du
dictionnaire d’identification que l’on rencontre plus loin dans le fichier. Chaque identification
dans le fichier doit avoir un nom unique.
Une identification est entrée dans le dictionnaire quand un tag de définition est rencontré dans
le fichier.
Une identification est cherchée dans le dictionnaire sur la base du numéro d’identification.
(4)Liste d’affichage
D’un point de vue théorique, un fichier « SWF » peut être divisé en deux parties :


La partie définition qui ajoute les identifications au dictionnaire
La partie contrôle qui exécute les opérations dans la « display list » en utilisant les
définitions définies dans le dictionnaire.
Depuis la version 3, la liste d’affichage est constituée d’une arborescence d’objets où un
élément peut avoir des éléments enfants. Les objets sont référencés par un numéro d’ordre. A
chaque niveau un seul objet peut exister.
Il existe trois opérations :



Placer un objet : place un caractère à un numéro d’ordre donné en utilisant une
transformation spécifiée.
Déplacer un objet : modifie un objet à un numéro d’ordre donné. Pendant la
transformation, il change le caractère.
Supprimer un objet : supprime un objet à un numéro d’ordre donné depuis l’affichage.
(5)Coordonnées
SWF utilise des entiers et des nombres de points fixes pour l’ensemble des coordonnées et des
matrices de transformations. Les coordonnées sont définies par des nombres entiers. Les
coordonnées en Flash sont déterminées en twips 1.
1
TWIP : Contraction pour twentieth of a point. Permet de mesurer la longueur. C'est une unité employée en
PAO. 1 twip est égal à 1/20ème de point, 1/1440ème de pouce.
Etude des API java pour la génération de code Flash - Page 15/59
Probatoire CNAM 2007 – Nicolas Botet
(6)Traitement d’un fichier SWF
Le modele de traitement d’un flux est que tous les tags sont traités en un flux jusqu’à ce qu’un
« ShowFrame tag » soit rencontré. A ce moment là, la « display list » est copiée à l’écran et le
lecteur se met en veille jusqu’au traitement de la prochaine Frame.
Un fichier SWF est divisé en plusieurs frames par des « show frame tag ». Le Frame 1 est
défini en effectuant toutes les opérations de contrôle avant le premier « show frame tag ». Le
Frame 2 est défini en effectuant toutes les opérations de contrôle avant le second « show
frame tag ».
(7)La stratégie de compression des fichiers
Etant donné que les fichiers SWF sont fréquemment utilisés sans tenir compte de la qualité du
réseau, il est important qu'ils soient aussi compacts que possible.
Voici plusieurs techniques :






Reuse : La structure dictionnaire de caractère permet très facilement de réutiliser des
éléments dans un fichier SWF. Une forme, un bouton, un son, une police, peuvent être
stockés dans un fichier une fois et réutilisés plusieurs fois.
Compression : Le contenu des « tags » est compressé. SWF supporte plusieurs
techniques de compression. Les bitmaps peuvent être compressés en JPEG. Le son est
comprimé en utilisant plusieurs niveaux de compression d'ADPCM1.
Bit Packing : quand c’est possible, des nombres sont emballés dans le plus petit
nombre de bits possible pour une valeur particulière. Utilisé pour les coordonnées.
Default values : Quelques éléments comme les matrices et la transformation de la
couleur ont des champs communs qui sont employés plus souvent que d'autres. Par
exemple, pour une matrice, le champ le plus commun est le champ de translation. Les
champs de graduation et de rotation sont moins communs. Par conséquent si le champ
de graduation n'est pas présent, on suppose que l’échelle est de 100%. Si le champ de
rotation n'est pas présent, on suppose qu'il n'y a aucune rotation. Cette utilisation des
valeurs par défaut aide à réduire au minimum la taille des fichiers.
Change Encoding : Dans un fichier SWF, les changements entre deux états sont
stockés. Les fichiers SWF stockent juste les changements entre les états. Ceci est
représenté dans la structure de données des formes et dans le modèle de
place/move/remove employé par la play list.
Shape Data Structure : Shape Data Structure utilise une structure de données unique
pour réduire au minimum la taille des formes et pour rendre un anti-aliased des formes
très efficace.
1
ADPCM : Sigle anglais correspondant à Modulation par impulsion et codage différentiel adaptatif. Cette
méthode de codage des fichiers sonores monopolise moins d'espace de stockage que le format PCM classique
utilisé par les fichiers WAV, AIFF et ceux des CD audio.
Etude des API java pour la génération de code Flash - Page 16/59
Probatoire CNAM 2007 – Nicolas Botet
Bien que les différents composants d’un fichier SWF soient compressés, il n'y a aucune
compression globale appliquée au fichier. Ceci permet au lecteur de traiter la structure du
fichier directement hors de la RAM sans le décompresser. Divers éléments, tels que les
formes et les sons peuvent être décompressés lorsqu’ils sont nécessaires.
(8)Manipulation d’un fichier flash.
Comme nous l’avons vu précédemment, un fichier flash peut fonctionner de plusieurs façons,
en le faisant interagir avec des éléments extérieurs, ou en le retravaillant à travers un fichier
FLA. La suite de cette étude, va permettre de travailler directement sur le fichier SWF sans
avoir besoin de passer par des phases de compilation ou par le biais de fichier FLA. Nous
verrons également que nous pourrons modifier des fichiers Action Script.
4.Le langage Action Script
a)Présentation
ActionScript est un langage de programmation orienté objet (POO), dérivé de la même norme
W3C que le JavaScript, l’ECMAScript quant à sa syntaxe et ressemblant à Java par sa
structure. Il est basé sur les prototypes, c’est-à-dire des objets qui servent à créer de nouveaux
objets par clonage, et il supporte tous les éléments d’un langage P.O.O. : classes, interfaces,
héritage, composition etc.
Contrairement à JavaScript, dont le modèle de document objet (DOM) est axé sur les fenêtres,
les documents ou les formulaires, le DOM d’AS3 se fonde sur les séquences de film
comportant des animations, du contenu sonore, du texte. De plus, tous les éléments
fonctionnent de manière asynchrone : les téléchargements se font sans s’attendre les uns les
autres.
Depuis sa première version, ActionScript implémente XML, permettant à la plateforme Flash
de recevoir et d’envoyer des informations structurées grâce au langage XML.
Les nouveautés de la version ActionScript 3 incluent le typage strict, la déclaration explicite
de classes, l’héritage et l’interfaçage.
b)Fonctionnement
Le code ActionScript est exécuté par la machine virtuelle ActionScript, un composant de
Flash Player. Le code est généralement compilé en pseudo-code binaire par un compilateur
(ex : Adobe Flash CS3 Professional, Flex Builder, Adobe Flex SDK, les services de données
Flex Data). Le pseudo-code binaire est incorporé aux fichiers SWF, qui est exécuté par Flash
Player dans l'environnement d'exécution.
Une autre façon d’utiliser le langage actionScript consiste à créer un fichier « AS » puis de le
compiler en fichier SWF à l’aide d’un outil libre comme MTASC 1.
1
MTASC : Motion-Twin ActionScript 2 Compiler
Etude des API java pour la génération de code Flash - Page 17/59
Probatoire CNAM 2007 – Nicolas Botet
Les fonctions principales d'ActionScript 3.0 sont les suivantes :






Une nouvelle machine virtuelle ActionScript, nommée AVM2, qui exploite un
nouveau jeu d'instructions de pseudo-code binaire et améliore grandement les
performances.
Une base de code de compilation plus moderne, davantage en accord avec la norme
ECMAScript (ECMA 262) et qui accomplit de meilleures optimisations que les
versions antérieures du compilateur.
Une interface de programmation (API) étendue et améliorée, avec contrôle de bas
niveau des objets et un véritable modèle orienté objet.
Un langage de base reposant sur la future version 4 de la spécification ECMAScript
(ECMA-262).
Une API XML reposant sur la spécification ECMAScript pour XML (E4X) (ECMA357 niveau 2). E4X est une extension de langage d'ECMAScript qui ajoute XML
comme type de données natif.
Un modèle d'événements fondés sur la spécification d'événements du modèle d'objet
de document (DOM, Document Object Model) niveau 3.
Etude des API java pour la génération de code Flash - Page 18/59
Probatoire CNAM 2007 – Nicolas Botet
5.Fonctionnement du lecteur Flash
Une application flash est programmée pour le lecteur Flash. Une animation Flash contient la
définition des objets qui seront créés, affichés et mis à jour tout au long de l’exécution du
fichier SWF.
Illustration 10 : Schéma représentant le modèle de programmation du lecteur Flash
Explication du schéma
Dictionary : Le dictionnaire est la table contenant la définition des objets (boutons, images,
sons etc.) qui seront affichés dans l’animation.
Chaque définition contient un identifiant unique qui lui permet d’être référencée quand une
instance est créée (forme particulière, bouton etc.) lors de l’affichage à l’écran.
Un nouvel élément est ajouté au dictionnaire quand la définition d’un objet est décodée depuis
une animation Flash.
Etude des API java pour la génération de code Flash - Page 19/59
Probatoire CNAM 2007 – Nicolas Botet
Display List : la liste d’affichage, composée de plusieurs couches, contrôle l’ordre dans le
quel seront affichés les objets dans l’écran « screen ». Le numéro de la couche permet de
contrôler, dans la pile, l’ordre d’affichage de l’objet pendant l’exécution de l’animation. Un
seul objet peut être placé à une couche donnée à un certain temps, comme l’identifiant unique
utilisé pour créer un objet depuis sa définition dans le dictionnaire, le numéro de la couche
peut être utilisé pour se référer à un objet. Un objet placé dans la liste d’affichage est toujours
visible jusqu’à ce qu’il soit explicitement supprimé. Une fois l’objet détruit, une autre
instance peut être créée à partir de sa définition si l’objet doit encore être affiché.
Movie List : la liste d’animation est utilisée pour gérer l’animation et les animations
attachées. La liste d’animation contient un nombre de niveau virtuel, équivalent aux couches
dans la liste d’affichage, qui est utilisée pour conserver un suivi de chaque animation chargée.
L’animation principale est chargée au niveau zéro. Les animations attachées qui seront
affichées dans l’animation principale seront chargées au niveau 1, puis 2 etc. Charger un
« sprite 1 » à un niveau, remplace le précédent. Cela permet à plusieurs séquences d’animation
d’être assemblée dans une seule animation.
Screen : l’écran, est un affichage de bit-mapped où le lecteur Flash rend les objets graphiques
pour créer une animation. Le « showFrame Tag » est décodé, les objets sont ajoutés à la liste
d’affichage puis envoyés au « screen ». Tous les graphiques et fontes sont lissés par le
principe d’anti-aliasing. Les coordonnées en Flash sont déterminées en twips 2.
En plus de la vidéo, le lecteur Flash supporte trois autres services qui permettent à l’utilisateur
d’interagir avec l’animation.



Le clavier afin de saisir des données et interagir avec l’application
Une souris pour permettre de cliquer sur les boutons et générer des événements
La lecture du son (qualité CD)
Instruction Buffer : endroit ou sont chargées les actions exécutées par le lecteur Flash
Instruction Pointer : Il contient les adresses des instructions suivantes devant être exécutées.
Chaque action contient 16-bit qui sont réservés à l’adresse dans « l’instruction pointeur » pour
obtenir l’adresse de l’instruction suivante dans « l’instruction buffer ».
Stack : La pile sert à l’exécution des calculs. Quand les actions sont exécutées les arguments
requis sont dépilés de la pile et les résultats sont repoussés sur la pile. Les valeurs poussées
sur la pile sont principalement des entiers ou des chaines de caractère.
String Table : quand les valeurs sont réutilisées lors de calcul
Registers : quand les valeurs sont réutilisées lors de calcul, elles sont stockées
temporairement.
Memory : La mémoire stocke des variables utilisées seulement par le lecteur Flash. Le nom
de la variable est déposé sur la pile (« stack »). La valeur de la variable est récupérée dans la
mémoire et déposée sur la pile. Pour ajouter une variable, sa valeur suivie de son nom sont
déposées sur la pile et une action est exécutée pour mettre à jour la variable en mémoire.
1
Une animation ou une image attachée à l’animation principale
TWIP : Contraction pour twentieth of a point. Permet de mesurer la longueur. C'est une unité employée en
PAO. 1 twip est égal à 1/20ème de point, 1/1440ème de pouce.
2
Etude des API java pour la génération de code Flash - Page 20/59
Probatoire CNAM 2007 – Nicolas Botet
III.La génération de code par les API JAVA
A.Introduction
Il existe plusieurs API java développées par des développeurs intéressés par la technologie
Flash. Nous verrons quelques unes des principales API existantes, chacune a ses spécificités,
certaines ne sont plus maintenues et deviennent obsolètes.
L’intérêt de générer du code Flash par le biais de Java réside dans le fait de pouvoir utiliser la
technologie java notamment côté serveur et d’utiliser un lecteur extrêmement portable, léger
et répandu dans le monde dans le but de proposer des applications dynamiques (notamment
RIA1) à l’interface graphique très attrayante. En effet, Flash offre une plus grande portabilité,
tout particulièrement pour la gestion graphique. Il est également plus simple d’intégrer des
animations (plus difficile à gérer en java) à des applications événementielles.
Pour les applications web, les fichiers SWF permettent de conserver tous les avantages de
Flash par rapport à Java : légèreté du téléchargement, moindre consommation mémoire,
possibilités graphiques étendues, performances graphiques supérieures, meilleure productivité
dans la réalisation d’effets graphiques.
L’intérêt d’utiliser java permet à des développeurs java de générer du code SWF sans utiliser
les applications propriétaires Adobe. De plus, en connaissant la spécification du format de
fichier SWF, il leur est permis, sans connaissance de langage Flash de développer des fichiers
Flash.
Le domaine d’application est vaste, car l’utilisation de ses API peut servir à :



Des applications clients serveurs : créer une application dynamique en utilisant le
Player Fash tout en générant le code à partir d’une plate forme JAVA.
Des applications autonomes : un diaporama transformé en fichier SWF (Open Office)
Développer des outils permettant de travailler sur des fichiers Flash
Liste des API étudiées :

Metaas 0.7 API

JavaSWF2

Flagstone Software TRANSORM

Flagstone Software TRANSLATE AS1

JSwiff
1
R.I.A. : Rich Internet Application, sont des applications qui partageant les caractéristiques des applications
autonomes tout en fonctionnant en mode client-serveur.
Etude des API java pour la génération de code Flash - Page 21/59
Probatoire CNAM 2007 – Nicolas Botet
B.Les API
1.Metaas 0.7 API
a)Présentation
L’API Metaas a pour principale fonction de générer du code Action Script 3 mais elle permet
également de charger des fichiers Acion Script et d’effectuer quelques modifications simples.
Cette API ne permet pas de générer des fichiers Flash ou des AS bytecode.
Son développement a été inspiré de JaxMe1 pour la génération du code JAVA.
Metaas est basé à l’origine sur la grammaire ANTLR 2 de Action Script 3 provenant du projet
ASDT3. Cette API est fournie sous licence LGPL 4 ce qui lui permet d’être utilisée librement
tout en respectant les clauses de la licence.
Nom
Version
Licence
Dernières modifications
Compatibilité Flash
Documentation fournie
Site Internet
Metaas
0.7
LGPL
17/03/2007
Action Script 3
**
http://www.badgers-in-foil.co.uk/projects/metaas/
Illustration 11 : Fiche récapitulative de l’API Metaas 0.7
b)Utilisation
L’utilisation de cette API va permettre aux développeurs JAVA de générer du code
ActionScript3. En effet, un fichier « .AS » sera généré. Ce fichier sera alors utilisé par un
fichier SWF lors de son exécution ou bien il sera compilé à l’aide d’un compilateur AS.
Illustration 12 : Exemple d’utilisation de l’API Metaas 0.7
1
JaxMe : un compilateur de liaisons Java - XML
ANTLR : ANother Tool for Language Recognition. C’est un générateur d'analyseur syntaxique et lexical
permettant de générer du code Java ou C++. Il peut générer des arbres syntaxiques abstraits (AST) et des classes
pour le parcourir.
3
ASDT : Action Script Development Tools, est un ensemble de plugins pour la plateforme Eclipse qui permet
d'écrire du code ActionScript2 dans un environnement intégré.
4
LGPL : Lesser General Public License (V. Annexe)
2
Etude des API java pour la génération de code Flash - Page 22/59
Probatoire CNAM 2007 – Nicolas Botet
c)Architecture
Cette A.P.I. fournit à JAVA deux packages.


Package uk.co.badgersinfoil.metaas : génération et manipulation du code Action
Script
Package uk.co.badgersinfoil.metaas.dom : Interface permettant de définir
« Document Object Model » pour le code source d’un fichier action script 3.
le
d)Quelques notions complémentaires sur l’utilisation de
cette A.P.I.
(1)Syntax Errors
Metaas contrôle les règles de syntaxe d’action Script :
meth.addStmt("trace(i)");
uk.co.badgersinfoil.metaas.SyntaxException:
RPAREN) in "trace(i)"
Unexpected
token
RBRACK
(expecting
(2)Inspection du code
Exemple à partir du code java ci-dessous pour lire le contenu du fichier « Test.as ».
FileInputStream in = new FileInputStream("Test.as");
InputStreamReader reader = new InputStreamReader(in);
ActionScriptFactory fact = new ActionScriptFactory();
ActionScriptParser parser = fact.newParser();
ASCompilationUnit unit = parser.parse(reader);
Il est alors possible d’utiliser les méthodes de l’Interface « ASCompilationUnit » du package
« uk.co.badgersinfoil.metaas.dom » pour explorer les types, les champs et les méthodes
définies dans le code source du fichier Action Script.
Par exemple, pour lister toutes les méthodes définies dans « Test.as », il suffit d’ajouter les
lignes suivantes à l'exemple ci-dessus :
ASPackage pkg = unit.getPackage();
ASType type = pkg.getType();
List methods = type.getMethods();
for (Iterator i=methods.iterator(); i.hasNext(); ) {
ASMethod meth = (ASMethod)i.next();
System.out.println(meth.getName());
}
Etude des API java pour la génération de code Flash - Page 23/59
Probatoire CNAM 2007 – Nicolas Botet
(3)Ajouter des commentaires
Metaas permet d’établir des commentaires JavaDoc-style des éléments de l’api avec
l'interface « Documentable » du package « uk.co.badgersinfoil.metaas.dom ».
Les éléments de l’interface « Documentable » fournissent une description simple du
commentaire, par l'intermédiaire de l’objet « DocComment ».
Exemple :
Nous allons ajouter un commentaire dans le code de l’exemple ci-dessus grâce à la fonction
« setDescription » :
ASCompilationUnit unit = proj.newClass("Test");
ASClassType clazz = (ASClassType)unit.getType();
clazz.setDescription("Test Commentaire.");
Le résultat en action script donne ceci :
package {
/**
* Test Commentaire.
*/
public class Test {
}
}
Plusieurs éléments fournissent leurs propres méthodes d’accès. Par exemple, « ASArg »
permet la manipulation des sections « @param » dans la documentation de la méthode,
ASMethod meth = clazz.newMethod("test", Visibility.PUBLIC, "void");
ASArg t = meth.addParam("t", "String");
t.setDescription("must not be null");
Le résultat en action script donne ceci :
/**
* @param t must not be null
*/
public functinon test(t:String):void {
}
Etude des API java pour la génération de code Flash - Page 24/59
Probatoire CNAM 2007 – Nicolas Botet
e)Exemple
Sujet : Génération d’un fichier « .as » dans un répertoire :
ActionScriptFactory fact = new ActionScriptFactory();
ActionScriptProject proj = fact.newEmptyASProject(".");
ASCompilationUnit unit = proj.newClass("Test");
ASClassType clazz = (ASClassType)unit.getType();
ASMethod meth = clazz.newMethod("test", Visibility.PUBLIC, "void");
meth.addStmt("trace('Hello world')");
proj.writeAll();
Explication de l’exemple
L’expression « proj.newClass("Test") » génère le code action script suivant :
package {
public class Test {
}
}
L’expression « clazz.newMethod("test", Visibility.PUBLIC, "void") » ajoute une méthode
dans la classe créée précédemment :
public function test():void {
}
L’expression « meth.addStatement("trace('Hello world')") » ajoute une ligne à la méthode
créée précédemment (un « ; » a été ajouté) :
trace('Hello world');
Pour finir, l’expression « proj.writeAll() » crée un fichier appelé « Test.as » dans le répertoire
courant comprenant le code si dessous :
package {
public class Test {
public function test():void {
trace('Hello world');
}
}
}
Cet exemple montre comment créer un fichier Action Script. Pour terminer l’exemple et
afficher ce résultat, il suffit de créer un fichier SWF devant exécuter le code du fichier
« Test.as ». Les mots « Hello word » seront alors affichés dans le lecteur Flash.
Etude des API java pour la génération de code Flash - Page 25/59
Probatoire CNAM 2007 – Nicolas Botet
Illustration 13 : Illustration de l’exemple utilisant l’API Metaas 0.7
f)Licence d’utilisation
Cette API est distribuée sous licence GNU Lesser General Public License. Cela signifie que le
code pourra être réutilisé sous certaines conditions. Cependant, l’application développée, si le
code de l’API n’est pas modifié, pourra ne pas être couvert par la licence LGPL.
g)Conclusion
Cette API fournit de nombreuses classes et méthodes pour manipuler et générer du code
action script 3. Elle est toujours en évolution et les dernières modifications sont récentes,
puisque la version 0.7 date du 17 mars 2007.
Les tests effectués sont concluants, si ce n’est, des difficultés lors de la manipulation des
fichiers Action Script quant à des problèmes de versions. Une API puissante pour générer et
modifier simplement des fichiers Action Script. Moins efficace pour manipuler des fichiers
« AS » générés par d’autres applications. Les fichiers manipulés devront être exécutés à l’aide
d’un fichier SWF. Cette API ne fournit pas de compilateur.
Etude des API java pour la génération de code Flash - Page 26/59
Probatoire CNAM 2007 – Nicolas Botet
2.JavaSWF2
a)Présentation
L’API « JavaSWF2 » fournit un ensemble de classes et de méthodes permettant d’analyser,
manipuler et générer des fichiers « SWF ». Cette API permet également de travailler sur le
code AcrionScript mais seulement sous sa forme compilée
La version actuelle, n’est pas tout à fait un produit fini car tous les tests n’ont pas été
effectués. Cependant aucun problème majeur n’a encore été décelé. Il semblerait que le projet
ne soit plus suivi de par la date de la dernière version datant du 29 juillet 2003. Cette API est
fournie sous licence BSD 1 ce qui lui permet d’être utilisée librement tout en respectant les
clauses de la licence.
Nom
Version
Licence
Dernières modifications
Domaine d’intervention Flash
Documentation fournie
Site Internet
JavaSWF2
020729
BSD
29/07/2003
Flash 4 et 5, action script
*
http://www.anotherbigidea.com/javaswf/
Illustration 14 : Fiche récapitulative de l’API JavaSWF2
b)Utilisation
L’utilisation de cette API va permettre aux développeurs JAVA de générer et d’analyser des
fichiers SWF.
Illustration 15 : Exemple d’utilisation de l’API JavaSWF2
1
BSD : Berkeley Software Distribution (V. Annexe)
Etude des API java pour la génération de code Flash - Page 27/59
Probatoire CNAM 2007 – Nicolas Botet
c)Architecture
Le
code
principal
se
situe
autour
des
interfaces
du
package
« com.anotherbigidea.flash.interfaces ».
Ces interfaces sont employées pour récupérer diverses informations sur le contenu d'un fichier
SWF. Les classes permettant d’analyser et d’écrire des fichiers SWF implémentent ces
interfaces.
L’interface clé « com.anotherbigidea.flash.interfaces » est utilisée pour manipuler des
informations sur le contenu des fichiers flash.
2 niveaux :

Le format du fichier : fournit tous les détails sur le format du fichier (analyse et
écriture). Très efficace, quand le format du fichier est connu et que l’on souhaite
implémenter rapidement une analyse ou une génération de code.

Le modèle objet : est implémenté par les classes du
package
« com.anotherbigidea.flash.movie » qui permet d’accéder et de générer du contenu
Flash sans connaître les détails du format du fichier.
Les packages :







com.anotherbigidea.flash
o dé protection de films flash
o constantes utilisées pour action script ou autre tag et flag
com.anotherbigidea.flash.interfaces
o interface pour passer de l’action code, des tags, header du fichier SWF
com.anotherbigidea.flash.readers
o lit les fichiers SWF
o analyse le contenu des tags
o convertit les fichiers SWF en XML
com.anotherbigidea.flash.writers
o écriture dans un stream ou un fichier
o représentation textuelle d’un film
com.anotherbigidea.flash.structs
com.anotherbigidea.flash.movie
com.anotherbigidea.flash.sound
Etude des API java pour la génération de code Flash - Page 28/59
Probatoire CNAM 2007 – Nicolas Botet
d)Quelques notions complémentaires sur l’utilisation de
cette A.P.I.
Manipulation d’XML et SWF
Pour compiler les classes mentionnées ci-dessous il faudra utiliser le package « org.xml.sax.»
1
dans le classpath. Ce sont les interfaces standards de SAX(2)
qui sont incluses dans
JavaSWF2 et devraient également inclure tous les packages récents d'analyseur de XML.
« Apache Xerces » et « Crimson parsers » sont recommandés, même si l’on peut utiliser
n'importe quel analyseur SAX2 conforme. Pour ce faire, un DTD 2 est fourni.

Convertir un fichier SWF en XML
Il faut utiliser la classe « com.anotherbigidea.flash.readers.SWFSaxParser » qui utilise
l'interface standard « org.xml.sax.XMLReader » et la classe « SWFTagTypes ».
La méthode principale de « SWFSaxParser » est une commande en ligne permettant de lire un
fichier SWF et de l’écrire XML.
/**
* Lit un fichier SWF (args[0]) et génère un fichier XML (args[1])
*/
public static void main( String[] args ) throws Exception
{
OutputStream out = new FileOutputStream( args[1] );
XMLWriter writer = new XMLWriter( out );
SWFSaxParser parser = new SWFSaxParser( writer, writer );
parser.parse( args[0] );
out.close();
}
1
SAX : « Simple API for XML », API java pour la manipulation XML.
DTD : « Document Type Definition », document qui fournit une grammaire afin de vérifier la conformité du
document XML.
2
Etude des API java pour la génération de code Flash - Page 29/59
Probatoire CNAM 2007 – Nicolas Botet

Convertir un fichier XML en SWF
Il faut utiliser la classe « com.anotherbigidea.flash.writers.SWFSaxWriter ». Il n’y a pas
d’utilitaire fourni pour passer d’un fichier XML à un fichier SWF pour ne pas qu’il y ait de
dépendance avec un analyseur particulier de XML. Cependant, voici un exemple qui utilise
l'analyseur de Xerces pour produire un fichier SWF.
import java.io.*;
import java.awt.*;
import com.anotherbigidea.flash.*;
import com.anotherbigidea.flash.movie.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.util.xml.Xerces;
/**
* Exemple pour convertir un fichier XML en SWF.
* Arg[0] = input xml filename
* Arg[1] = output swf filename
*/
public class Xml2Swf
{
public static void main( String[] args ) throws Exception
{
FileInputStream in = new FileInputStream( args[0] );
SWFWriter swftags = new SWFWriter( args[1] );
TagWriter tagwriter = new TagWriter( swftags );
SWFSaxWriter saxout = new SWFSaxWriter( tagwriter );
Xerces.parse( saxout, in );
}
}
Etude des API java pour la génération de code Flash - Page 30/59
Probatoire CNAM 2007 – Nicolas Botet
e)Exemple
Cet exemple proposé par l’API JavaSWF2, permet d’illustrer la création d’un fichier SWF
affichant une forme géométrique.
Dans cet exemple, nous utiliserons principalement les objets :
 Movie : contient l’animation
 Frame : gestion du Frame
 MovieClip : gestion de Movie Clip
import java.io.*;
import com.anotherbigidea.flash.interfaces.*;
import com.anotherbigidea.flash.writers.*;
import com.anotherbigidea.flash.structs.*;
import com.anotherbigidea.flash.movie.*;
/**
* Exemple utilisant le package Movie pour créer une simple animation Flash constitué de 4 instances
* de Movie Clip contenant carré rouge tournant.
*/
public class RedSquare
{
/**
* le premier argument est le nom du fichier de sortie
*/
public static void main( String[] args ) throws IOException
{
Movie movie = new Movie();
//-- Créer un carré rouge avec un contour noir
Shape shape = new Shape();
shape.defineFillStyle( new Color(255,0,0) );
shape.defineLineStyle( 2.0, new Color(0,0,0) );
shape.setRightFillStyle( 1 );
shape.setLineStyle( 1 );
shape.move( -50, -50 );
shape.line( 50, -50 );
shape.line( 50, 50 );
shape.line( -50, 50 );
shape.line( -50, -50 );
//--Création du Movie Clip (Sprite)
MovieClip clip = new MovieClip();
Frame f1 = clip.appendFrame();
//--Place le carré rouge au entre du Movie Clip
Instance inst = f1.placeSymbol( shape, 0, 0 );
//--Rotation du carré (utilisation en degrés)
for( int angle = 10; angle < 90; angle += 10 )
{
//--Conversion des degrés en angle
double radians = angle * Math.PI / 180.0;
Frame f = clip.appendFrame();
//--Création d’un matrice de rotation
Transform matrix = new Transform( radians, 0.0, 0.0 );
//--Changer le carré en utilisant la matrice de transformation
f.alter( inst, matrix, null );
}
//-- Ajouter une simple frame à l’animation et lui donner l'action de s’arrêter pour
// l’empêcher de faire une boucle (les boucles de Movie Clip sont indépendantes)
Frame frame = movie.appendFrame();
frame.stop();
Etude des API java pour la génération de code Flash - Page 31/59
Probatoire CNAM 2007 – Nicolas Botet
//--Positionne 4 instances de Movie Clip
frame.placeSymbol( clip, 100, 100 );
frame.placeSymbol( clip, 300, 100 );
frame.placeSymbol( clip, 100, 300 );
frame.placeSymbol( clip, 300, 300 );
//--Sauve l’animation dans le fichier de sortie
movie.write( args[0] );
}
}
Illustration 16 : Illustration de l’exemple utilisant l’API JavaSWF2
f)Licence d’utilisation
Le code source de l’API pourra être réutilisé sous la licence Berkeley Software Distribution
License. Cela signifie que le code peut être librement réutilisé en respectant les indications
spécifiées ci-dessous.
The JavaSWF2-BSD License
Copyright (c) 2001, David N. Main, All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
1.
2.
3.
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other materials provided with the distribution.
The name of the author may not be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR « AS IS » AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Etude des API java pour la génération de code Flash - Page 32/59
Probatoire CNAM 2007 – Nicolas Botet
g)Conclusion
Cette API fournit quelques classes et méthodes pour manipuler et générer des fichiers Flash 4
et 5 ainsi que de l’action Script. Elle n’est plus suivie, la dernière modification date du mois
de juillet 2003. La documentation propose quelques exemples, mais peu d’explications.
L’accent est mis sur la manipulation des fichiers XML et SWF.
Etude des API java pour la génération de code Flash - Page 33/59
Probatoire CNAM 2007 – Nicolas Botet
3.Transfom SWF
a)Présentation
Cette API permet de lire, d’écrire et de manipuler des fichiers SWF. En plus des classes de
base qui composent le noyau, l’API fournit une interface de plus haut niveau afin de faciliter
1
la mise en œuvre d’application. Cette API est fournie sous licence BSD
ce qui lui permet
d’être utilisée librement tout en respectant les clauses de la licence.
De plus, Flagstone Software propose « Describe SWF »un outil permettant l’analyse des tags
d’un fichier SWF. Il permet, tout en offrant plusieurs vues (texte, binaire, hexadécimal et
description), de déterminer les tags utilisés ainsi que leur contenu.
Nom
Transfom SWF
Version
Licence
Dernières modifications
Domaine d’intervention Flash
2.1.5
BSD
03/01/2007
 Manipulation Flash7
 Analyse et génère Flash9
***
Describe SWF
http://www.flagstonesoftware.com/
Documentation fournie
Outil fourni par l’API
Site Internet
Illustration 17 : Fiche récapitulative de l’API Transform SWF
b)Utilisation
L’utilisation de cette API va permettre aux développeurs JAVA de générer et d’analyser des
fichiers SWF.
Illustration 18 : Exemple d’utilisation de l’API Transform SWF
1
BSD : Berkeley Software Distribution (V. Annexe)
Etude des API java pour la génération de code Flash - Page 34/59
Probatoire CNAM 2007 – Nicolas Botet
c)Architecture
Transform SWF, fournit une collection de classes pour chacun des tags et structures de
données qui constituent un fichier Flash. La classe «FSMovie » est la classe pivot qui permet
de décrire une animation Flash. Elle contient les instances des classes qui représentent chaque
type de tags.
Les packages :


com.flagstone.transform : ce package permet de lire et d’écrire des fichiers Flash.
com.flagstone.transform.util : ce package permet d’ajouter facilement des images, du
texte et du son à des films.
d)Exemple
Dans cet exemple, proposé par la documentation de l’API, nous verrons l’utilisation de la
classe « FSMovie » ainsi que l’utilisation de certaines de ses fonctions.
Cet extrait montre comment créer une animation Flash permettant l’affichage d’un rectangle.
Dans le code original, deux classes sont utilisées :
 La classe abstraite « Example.java » : contenant le code permettant de créer l’objet
« movie »
 La classe « MovieBasics.java » : contenant le code permettant la conception de
l’animation flash.
Déroulement du code :
1. L’objet movie est instancié :
movie = new FSMovie();
2. La procédure « createMovie() » permet de créé l’objet qui deviendra après
compilation un fichier SWF :
public void createMovie()
{
/*
* La taille de l'animation est spécifiée en pixels (contrôlé par les champs
* COORDINATES_ARE_PIXELS dans le package transform. Les limites du rectangle sont
* définies par 2 points : le coin en bas à gauche et le coin en haut à droite
*
* La limite du rectangle définit également les coordonnés pour les axes x et y
* Ici les coordonnées pour les axe des x et des y s'étendent de -200 à + 200. Le point
* (0,0) se situ au centre de l'écran.
*
* Si les coordonnées des coins étaient indiquées à (0.0) et (400, 400) la taille
* de l'écran serait toujours identique cependant le centre trouverait à (200.200)
*/
int xLower = -4000;
int yLower = -4000;
int xUpper = 4000;
int yUpper = 4000;
/*
Etude des API java pour la génération de code Flash - Page 35/59
Probatoire CNAM 2007 – Nicolas Botet
* Définit la fréquence de frame à laquelle l'animation serait jouée.
*/
float framesPerSecond = 1.0f;
movie.setFrameRate(framesPerSecond);
movie.setFrameSize(new FSBounds(xLower, yLower, xUpper, yUpper));
/*
* Définit la couleur du fond de l'écran à bleu.
* La couleur de fond est définit une seule fois et devrait être le premier objet
* à être ajouté à l'animation. Si aucune couleur n'est spécifiée, le lecteur définira un
* fond blanc.
*/
movie.add(new FSSetBackgroundColor(FSColorTable.lightblue()));
/*
* Définit une forme à afficher. Chaque objet doit posséder un identifiant unique
* qui est utilisé pour identifier l'objet quand il est ajouté, mise à jour ou supprimé
* de la display list.
* L'objet movie, garde la trace des identifiant pour garantir leurs unicités de chacun.
*/
int identifier = movie.newIdentifier();
int width = 4000;
int height = 4000;
FSBounds bounds = new FSBounds(-2000, -2000, 2000, 2000);
ArrayList lineStyles = new ArrayList();
ArrayList fillStyles = new ArrayList();
lineStyles.add(new FSSolidLine(20, FSColorTable.black()));
fillStyles.add(new FSSolidFill(FSColorTable.red()));
/*
* Création du contour de la forme.
*/
ArrayList shapeRecords = new ArrayList();
shapeRecords.add(new FSShapeStyle(1, 1, 0, -width/2, -height/2));
shapeRecords.add(new FSLine(width, 0));
shapeRecords.add(new FSLine(0, height));
shapeRecords.add(new FSLine(-width, 0));
shapeRecords.add(new FSLine(0, -height));
FSDefineShape rectangle = new FSDefineShape(identifier, bounds, fillStyles, lineStyles, new FSShape(shapeRecords));
/*
* Ajoute le rectangle à l'animation. Toutes les formes et les objets doivent être définis
* avant qu'ils puissent être placé dans la display list et affiché dans le lecteur Flash
*/
movie.add(rectangle);
/*
* Position de la forme dans la display list. Voir l'exemple pour l'ensemble
* des objets qui seront utilisés pour ajouter, modifier et effacer des objets
* de la display list.
*/
movie.add(new FSPlaceObject(identifier, 1, 0, 0));
/*
* Montre le contenu de la display list. Les frames sont délimité par
* la succession des objets FSShowFrame
*/
movie.add(new FSShowFrame());
}
}
3. Lancement de la procédure permettant la compilation et la génération du fichier Flash
writeFile("MovieBasics.swf");
/* writeFile est utilisé pour coder les objets et pour les écrire dans un fichier Flash.
* Pour créer une animation Flash chacune des structures de données
Etude des API java pour la génération de code Flash - Page 36/59
Probatoire CNAM 2007 – Nicolas Botet
* sont ajoutés à l'objet movie. Le fichier Flash codé est alors produit
* en appelant la méthode encodeToFile de l'objet FSMovie ().
*/
public void writeFile(String fileName)
{
try
{
movie.encodeToFile(resultDir + fileName);
}
catch (FileNotFoundException e)
{
System.err.println("Cannot open file: " + e.getMessage());
}
catch (IOException e)
{
System.err.println("Cannot write to file: " + e.getMessage());
}
}
Illustration 19 : Résultat de l’exemple utilisant l’API Transform SWF
Illustration 20 : Illustration de l’exemple utilisant l’API Transform SWF
Etude des API java pour la génération de code Flash - Page 37/59
Probatoire CNAM 2007 – Nicolas Botet
e)Licence d’utilisation
The Flagstone Software-BSD License
All the files in this library are covered under the terms of the Berkeley Software Distribution (BSD) License:
Copyright (c) 2001-2006 Flagstone Software Ltd. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following
disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of Flagstone Software Ltd. nor the names of its contributors may be used to endorse or
promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
f)Conclusion
Cette API, disponible sous licence BSD, offre de multiples possibilités pour la manipulation
et la création de fichier flash. Elle permet de travailler sur des fichiers Flash de dernière
génération (v.9).
L’API est complète, elle fournit de nombreux exemples tout en étant très bien documentée.
Elle s’intègre avec l’API Translate AS1 qui permet de manipuler du code Action Script 1.0.
Etude des API java pour la génération de code Flash - Page 38/59
Probatoire CNAM 2007 – Nicolas Botet
4.Translate AS1
a)Présentation
Cette API permet de compiler du code Action Script. Le code peut être ajouté aux objets de «
Transfom SWF » ou intégré à une librairie Flash tierce. Elle permet de créer des scripts
permettant la gestion d’événement déclenché par la souris ou le clavier. Le code généré est
compilé. Cette API est fournie sous licence GPL 1se qui lui permet d’être utilisée librement
tout en respectant les clauses de la licence, ou pour un usage commercial sous la licence
Flagstone Software License.
De plus, Flagstone Software propose « Describe SWF »un outil permettant l’analyse des tags
d’un fichier SWF. Il permet, tout en offrant plusieurs vues (texte, binaire, hexadécimal et
description), de déterminer les tags utilisés ainsi que leur contenu.
Nom
Translate AS1
Version
Licence
Dernières modifications
Domaine d’intervention Flash
Documentation fournie
Outil fourni par l’API
Site Internet
2.0.4
GPL et Flagstone Software License
03/01/2007
Action script 1.x
***
Describe SWF
http://www.flagstonesoftware.com/
Illustration 21 : Fiche récapitulative de l’API Translate AS1
b)Utilisation
L’utilisation de cette API va permettre aux développeurs JAVA de générer et d’analyser des
fichiers SWF à l’aide du code ActionScript. Cette API peut être utilisée avec l’API
« TransformSWF ».
Illustration 22 : Exemple d’utilisation de l’API Translate AS1
1
GPL : General Public License (V. Annexe)
Etude des API java pour la génération de code Flash - Page 39/59
Probatoire CNAM 2007 – Nicolas Botet
c)Architecture
Translate AS1 est une collection de classes utilisées pour mettre en application un compilateur
pour la version 1.0 d'ActionScript de Macromedia. Des scripts ActionScript sont analysés
pour produire des byte-codes et des actions qui seront exécutés par le player Flash.
Un package :

com.flagstone.translate : ce package permet d’implémenter un compilateur pour le
langage ActionScript 1.0 de Macromedia.
Le processus de compilation se décompose en deux étapes :

Le script est analysé et converti en arbre composé de « ASNode »

Le résultat est codé au format de fichier « SWF » qui spécifie le code et les actions à
exécuter par le lecteur Flash.
d)Exemple
String script = "a = b + c;"
int swfVersion = 5;
ASParser parser = new ASParser();
ASNode root = parser.parse(script);
byte[] data = root.encode(swfVersion);
La version du flash à laquelle on codera les « ASNodes » est passée au nœud racine. Le
format des structures de données correspondant au « movie clip events » et au « button
events » ayant changé entre la version 6 et 7, il est nécessaire de renseigner le numéro de
version pour coder les nœuds correctement.
Les événements lié à l’affichage d’une frame
Les scripts qui seront exécutés quand une frame est affichée peuvent être encodés puis
ajoutés à un objet FSDoAction.
String script = "gotoFrame(1)";
byte[] encodedActions = parser.parse(script).encode(swfVersion);
FSDoAction frameActions = new FSDoAction(encodedActions);
movie.add(frameActions);
Les événements liés à l’utilisation d’un bouton
Deux possibilités pour gérer les événements liés à l’utilisation de boutons :

Les actions qui sont exécutées en réponse à un ensemble d'un ou plusieurs
événements, sont ajoutées à un objet de FSButtonEvent
Etude des API java pour la génération de code Flash - Page 40/59
Probatoire CNAM 2007 – Nicolas Botet
String script = "gotoFrame(1)";
int event = FSButtonEvent.Release;
byte[] encodedActions = parser.parse(script).encode(swfVersion);
FSButtonEvent eventActions = new FSButtonEvent(event, encodedActions);
...
button.add(eventActions);
...
movie.add(button);

Le bloc « on () » est fourni pour indiquer l’utilisation de plusieurs événements. Une
fois utilisés dans un script les nœuds sont codés en un tableau d’objet d’événement et
sont ajoutés à un objet FSDefineButton2.
// This script advances the movie by 10 frames each time a button is clicked.
String script = "
on (press)
{
frameNumber = currentFrame + 10;
}
on (release)
{
currentFrame = frameNumber
gotoFrame(frameNumber);
}
";
byte[] encodedActions = parser.parse(script).encode(swfVersion);
...
button.add(encodedActions);
...
movie.add(button);
Utilisation de l’objet « ASNode »
Produire des objets « ASNodes » comme étape intermédiaire a deux avantages :


Des sections du code fréquemment utilisées peuvent être analysées une fois et être
alors codées dans les différents objets améliorant considérablement l'exécution d’une
animation.
Pour les scripts simples, les arbres peuvent être construits « manuellement ».
La classe propose une gamme complète de type de nœud permettant de gérer des structures
complexes telles que des structures itératives, conditionnelles et les boucles.
Exemple utilisant « Example.java »
Dans cet exemple, proposé par la documentation de l’API, nous verrons l’utilisation de
certaines classes que compose cette API. L’API « transformSWF » sera également utilisée.
Cet exemple montre comment utiliser cette API pour compiler du code ActionScript et
l’ajouter à une animation.
Dans le code original, deux classes sont utilisées :
 La classe abstraite « Example.java » : contenant le code permettant de créer l’objet
« movie »
 La classe « MovieClip.java » : contenant le code permettant la conception de
l’animation flash.
Etude des API java pour la génération de code Flash - Page 41/59
Probatoire CNAM 2007 – Nicolas Botet
/*
* MovieClip.java
* Examples
*
* Created by Stuart MacKay on Sun Jun 13 2004.
* Copyright (c) 2004 Flagstone Software Ltd. All rights reserved.
*
* This code is distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND Flagstone HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING
* WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
*/
package com.flagstone.translate.examples;
import com.flagstone.transform.*;
import com.flagstone.translate.*;
import com.flagstone.transform.examples.*;
import java.io.*;
import java.util.*;
/* Cette exemple présente comment utiliser Translate pour compiler en action script
* et pour contrôler une animation
*
* Pour exécuter cet exemple il faut taper la ligne de commande suivante :
*
* java com.flagstone.translate.examples.MovieClip --file script [--resultDir path]
*
* où
*
* script est le fichier contenant le code ActionScript qui sera exécuté pour
* contrôler l'animation
*
* path est le répertoire où le fichier Flash sera généré
*
*
*/
public class MovieClip extends Example
{
public static void main(String[] args)
{
new MovieClip(args);
}
public MovieClip(String[] args)
{
super(args);
int screenWidth = 8000;
int screenHeight = 8000;
int swfVersion = 5;
String filename = getOption("file", "");
ASParser parser = new ASParser();
try
{
/*
* Le movie clip est le plus simple possible, l’affichage d’un simple rectangle
* pour une seule Frame
*/
FSDefineShape rectangle = rectangle(movie.newIdentifier(), 2000, 2000, FSColorTable.red());
FSDefineMovieClip clip = new FSDefineMovieClip(movie.newIdentifier());
clip.add(new FSPlaceObject2(rectangle.getIdentifier(), 1, 0, 0));
clip.add(new FSShowFrame());
String script = contentsOfFile(filename);
byte[] events = parser.parse(script).encode(swfVersion);
FSPlaceObject2 location = new FSPlaceObject2(clip.getIdentifier(), 1, events, "clip",
screenWidth/2, screenHeight/2);
Etude des API java pour la génération de code Flash - Page 42/59
Probatoire CNAM 2007 – Nicolas Botet
/*
* Met tous les objets dans l’objet movie.
*/
movie.setFrameRate(12.0f);
movie.setFrameSize(new FSBounds(0, 0, screenWidth, screenHeight));
movie.add(new FSSetBackgroundColor(FSColorTable.lightblue()));
movie.add(rectangle);
movie.add(clip);
movie.add(location);
movie.add(new FSShowFrame());
writeFile("MovieClip.swf");
}
catch (FileNotFoundException e)
{
System.err.println("Could not open file: " + filename);
}
catch (IOException e)
{
System.err.println("Could not read file: " + filename);
}
catch (ParseException e)
{
/*
* si le parser détecte une erreur dans le script une « parseExeption » sera déclenchée
* le parseur peut être utilisé pour rapporter une erreur et où elle s’est produite dans le manuscrit.
*/
System.err.println(parser.getError());
System.err.println("Line: " + parser.getLineNumber());
System.err.println(parser.getLine());
}
}
/* Définition d’un simple rectangle rempli avec un contour plein.
*
* @param Identifier l’unique identifiant utilisé pour référencer la Shape définition.
* @param width la largeur du rectangle en twips.
* @param height la hauteur du rectangle en twips.
* @param color la couleur utilisée pour remplir le contenu du rectangle.
*/
private FSDefineShape rectangle(int identifier, int width, int height, FSColor color)
{
FSBounds bounds = new FSBounds(-width/2, -height/2, width/2, height/2);
ArrayList lineStyles = new ArrayList();
ArrayList fillStyles = new ArrayList();
lineStyles.add(new FSSolidLine(20, FSColorTable.black()));
fillStyles.add(new FSSolidFill(color));
ArrayList shapeRecords = new ArrayList();
shapeRecords.add(new FSShapeStyle(1, 1, 0, -width/2, -height/2));
shapeRecords.add(new FSLine(width, 0));
shapeRecords.add(new FSLine(0, height));
shapeRecords.add(new FSLine(-width, 0));
shapeRecords.add(new FSLine(0, -height));
return new FSDefineShape(identifier, bounds, fillStyles, lineStyles, new FSShape(shapeRecords));
}
/* Retourne le contenu du fichier comme une simple chaine.
*
* @param fileName le nom du fichier à lire.
*
* @return une String contenant le contenu du fichier.
*
* @throws FileNotFoundException si le fichier n’est pas trouvé.
* @throws IOException si une erreur apparaît pendant la lecture du fichier.
*/
private String contentsOfFile(String fileName) throws FileNotFoundException, IOException
{
String script = "";
File aFile = new File(fileName);
Etude des API java pour la génération de code Flash - Page 43/59
Probatoire CNAM 2007 – Nicolas Botet
if (aFile.exists())
{
byte[] fileIn = new byte[(int)aFile.length()];
FileInputStream fileContents = new FileInputStream(aFile);
fileContents.read(fileIn);
script = new String(fileIn);
fileContents.close();
}
else
{
throw new FileNotFoundException();
}
return script;
}
}
Illustration 23 : Illustration de l’exemple utilisant l’API Translate AS1
e)Licence d’utilisation
Cette API est fournie sous deux formes de licences différentes.
Une licence pour le développement d’application libre (GNU General Public License) et une
licence pour le développement d’application dont le code est propriétaire (Flagstone Software
License). En effet, le code source de l’API peut être utilisé sans que le code source principal
soit « open source ».
Etude des API java pour la génération de code Flash - Page 44/59
Probatoire CNAM 2007 – Nicolas Botet
f)Conclusion
Cette API, permet la génération de code SWF grâce à l’utilisation du langage action Script1.
Action Script1 est maintenant dépassé puisque la dernière version est l’Action Script 3. Cette
API peut servir dans le cadre d’analyse de fichier AS1 et surtout dans la génération de code
notamment en utilisant l’API Transform, offrant un large potentiel pour la génération de
fichier Flash.
Etude des API java pour la génération de code Flash - Page 45/59
Probatoire CNAM 2007 – Nicolas Botet
5.JSwiff
a)Présentation
L’API JSwiff a pour principale fonction de générer et d’analyser des fichiers « SWF ». Pour
cela, elle se sert des tags qui seront analysés ou créés. D’après les spécifications, cette API ne
permet pas, sans utiliser les tags, l’utilisation d’objets tels que les sons ou les images. Il en est
de même pour la création de fichiers SWF à partir de fichier XML. Cette API est fournie sous
licence GPL 1 ce qui lui permet d’être utilisée librement tout en respectant les clauses de la
licence. En cas de développement d’un logiciel propriétaire, il existe une licence
commerciale.
Nom
Version
Licence
Dernières modifications
Domaine d’intervention Flash
Documentation fournie
Outil fourni par l’API
Site Internet
JSwiff
8
GPL ou commerciale
Forum actif
Flash 8
***
JSwiff Investigator
http://www.jswiff.com/
Illustration 24 : Fiche récapitulative de l’API JSwiff
b)Utilisation
L’utilisation de cette API va permettre aux développeurs JAVA de générer et d’analyser des
fichiers SWF.
Illustration 25 : Exemple d’utilisation de l’API JSwiff
1
GPL : General Public License (V. Annexe)
Etude des API java pour la génération de code Flash - Page 46/59
Probatoire CNAM 2007 – Nicolas Botet
c)Architecture
L’API JSwiff permet la création de documents Flash. Pour cela, un document SWF est créé,
des tags lui sont ajoutés et enfin le document sera généré en fichier Flash.
Lors de la création d’un fichier Flash, la difficulté réside dans le choix et la configuration des
tags SWF.
L’API est composé de 10 packages :










com.jswiff : lecture et écriture de documents SWF
com.jswiff.hl.factories : création de document SWF à partir de documents multimédias
com.jswiff.io : implémente un bit stream pour la lecture ou l’écriture de documents
SWF
com.jswiff.listeners : creation SWFDocument
com.jswiff.swfrecords : gestion des objets qui seront affichés
com.jswiff.swfrecords.actions : gestion des actions
com.jswiff.swfrecords.tags : gestion des tags pour la création de document SWF
com.jswiff.tutorials : exemple pour utiliser l’API
com.jswiff.util : quelques classes utilitaires
com.jswiff.xml : gestion du XML
Etude des API java pour la génération de code Flash - Page 47/59
Probatoire CNAM 2007 – Nicolas Botet
d)Exemple
Exemple permettant la génération d’un fichier SWF
import com.jswiff.swfrecords.tags.*;
import com.jswiff.swfrecords.*;
import com.jswiff.*;
import java.util.*;
import java.io.*;
class Test {
public static void main(String[] args) {
String fileName
= "tutorial.swf";
SWFDocument document = createDocument();
try {
writeDocument(document, fileName);
} catch (IOException e) {
System.out.println("An error occured while writing " + fileName + ":");
e.printStackTrace();
}
}
private static void writeDocument(SWFDocument document, String fileName)
throws IOException {
SWFWriter writer = new SWFWriter(document, new FileOutputStream(fileName));
writer.write();
}
private static SWFDocument createDocument() {
// Création d’un nouveau document SWF
SWFDocument document = new SWFDocument();
// Définition de la fonte du texte
// Attribution d’un nouveau ID pour la fonte
int fontId = document.getNewCharacterId();
// Utilisation d’une fonte standard (Arial), we don't want to define shapes for each glyph
DefineFont2 defineFont2 = new DefineFont2(fontId, "Arial", null, null);
document.addTag(defineFont2);
// Attribution d’un nouveau ID pour le texte
int textId = document.getNewCharacterId();
// Utilisation du texte dynamique avec DefineEditText
DefineEditText defineEditText = new DefineEditText(
textId, new Rect(0, 0, 0, 0), null);
// Dimension du rectangle du texte à 0 donc « autosise » pour le visualiser.
defineEditText.setAutoSize(true);
// Attribution de la taille du texte 24 px en twips
defineEditText.setFont(fontId, 20 * 24);
// defintion de la couleur rouge pour le texte
defineEditText.setTextColor(new RGBA(255, 0, 0, 255));
// attribution « readOnly » au texte
defineEditText.setReadOnly(true);
// attribution du texte
defineEditText.setInitialText("Hello world!");
document.addTag(defineEditText);
// Poistionnement du texte à depth 1
PlaceObject2 placeObject2 = new PlaceObject2(1);
placeObject2.setCharacterId(textId);
// positionnement du texte an twips (45; 10)
placeObject2.setMatrix(new Matrix(20 * 45, 20 * 10));
document.addTag(placeObject2); // place le texte
document.addTag(new ShowFrame()); // show frame
return document;
}
}
Etude des API java pour la génération de code Flash - Page 48/59
Probatoire CNAM 2007 – Nicolas Botet
Création de deux fichiers « .bat »


Compil.bat : « javac -classpath D:\TestProba\JSwif\jswiff-8.0-beta-2\src\; Test.java »
Run.bat : « java -classpath D:\TestProba\JSwif\jswiff-8.0-beta-2\src; Test »
Illustration 26 : Création du fichier swf dans l’exemple utilisant l’API Transform SWF
Observations :
Après exécution du fichier «test.java », le fichier « tutorial.swf » a été généré. Le fichier
« hello.html » servira à afficher le fichier « SWF » dans le navigateur.
Illustration 27 : Résultat « tutorial.swf » dans l’exemple utilisant l’API Transform SWF
Etude des API java pour la génération de code Flash - Page 49/59
Probatoire CNAM 2007 – Nicolas Botet
Illustration 28 : Illustration de l’exemple utilisant l’API JSwiff
e)Licence d’utilisation
Cette API est fournie sous deux formes de licences différentes.
Une licence pour le développement d’application libre (GNU General Public License) et une
licence pour le développement d’application dont le code est propriétaire (commercial
licensing option). En effet, le code source de l’API peut être utilisé sans que le code source
principal soit sous licence « GPL » à condition de souscrire une licence commerciale.
f)Conclusion
Bien que cette API n’exploite pas les dernières fonctionnalités de Flash, elle propose un
ensemble de package offrant au développeur java un large éventail de possibilités notamment
pour la réalisation de fichier SWF.
Etude des API java pour la génération de code Flash - Page 50/59
Probatoire CNAM 2007 – Nicolas Botet
C.Comparaison des différentes API
Nous avons étudié plusieurs API Java permettant la génération de code Flash. Toutes ont leurs
spécificités et certaines sont complémentaires. Elles sont différentes de par la compatibilité de
la version Flash qu’elles pourront traiter, leur utilisation, leurs possibilités et l’activité des
forums.
Voici une classification permettant de les comparer.
1.Mise à jour de l’API
Si l’on s’intéresse, pour des raisons de pérennité, à une API évolutive et suscitant une
évolution de par ses développeurs, nous pouvons proposer le classement suivant :
API ne présentant pas un suivi récent :


JSwiff (2006)
JavaSWF2 (juillet 2003)
D’autres sont actualisées régulièrement et ont été mis à jour récemment :


Flagstone Software (janvier 2007)
Metaas (mars 2007)
2.Utilisation en fonction de la version Flash
Il est également intéressant de les comparer entre elles sur leurs compatibilités avec les
versions Flash. En effet, si l’on souhaite créer une animation Flash, au delà des nouvelles
fonctionnalités, la version du fichier SWF sera lisible par un lecteur Flash dernière génération.
Cependant, si l’on souhaite modifier ou analyser un fichier SWF dont la version est
supérieure, alors ce sera plus compliqué voire impossible.
Aujourd’hui, Flash propose la version 9.
Etude des API java pour la génération de code Flash - Page 51/59
Probatoire CNAM 2007 – Nicolas Botet
a)Compatibilité Flash
Compatibilité Flash 5 :



JAVASWF2
Transform SWF
JSwiff
Compatibilité Flash 7 :


Transform SWF (manipulation)
JSwiff
Compatibilité Flash 8 :


Transform SWF
JSwiff
Compatibilité Flash 9 :

Transform SWF
b)Compatibilité Action script
Action Script 1 :



JavaSWF2
Ttranlate AS1
JSwiff
Action Script 2 :


JavaSWF2
JSwiff
Action Script 3 :

Metaas
Etude des API java pour la génération de code Flash - Page 52/59
Probatoire CNAM 2007 – Nicolas Botet
3.Les licences
Les licences sous lesquelles sont distribuées ces API auront une influence sur la licence de
l’application développée. Ces API sont toutes proposées sous licence OpenSource pour une
utilisation non propriétaire. En effet certaines proposent une licence commerciale.
Licence LGPL
 Metaas
Licence GPL
 JSwiff
 Flagstone Translate AS1
Licence BSD
 JavaSWF2
 Flagstone Transform SWF
Utilisation pour un code source propriétaire
Les API
Flagstone Translate AS1 et JSwiff proposent une licence spéciale pour le
développement d’animation flash dont le code est propriétaire. JSwiff propose une licence
payante.
4.En résumé
Toutes ces API permettent la génération de code Flash. Chacune aura une utilité en fonction
du besoin exprimé par le développeur que se soit dans le cadre d’une création d’une animation
ou dans le cadre d’une manipulation d’animation.
a)Création d’animation
Dans le cas d’une création d’application Flash, il semble intéressant d’utiliser l’API Metaas
qui permettra de manipuler et générer du code Action Scrip3. Il sera également intéressant
d’utiliser l’API Flagstone qui génère et analyse des animations Flash version 9. L’utilisation
simultanée des ces deux API offrirait au développeur la manipulation de code AS3 et Flash9.
b)Modification d’animation
Dans le cas où le développeur souhaite manipuler une animation Flash existante, la
connaissance de la version Flash utilisée est importante pour choisir l’API appropriée. L’API
JSwiff est très bien documenté et permet la manipulation d’animation Flash de la version 1 à
8. Dans le cadre de l’utilisation de l’API JSwiff pour une application dont le code serait
propriétaire, une licence payante est à souscrire.
Etude des API java pour la génération de code Flash - Page 53/59
Probatoire CNAM 2007 – Nicolas Botet
API
Metaas
JavaSWF2
Flagstone Transform SWF
F
Dernière Version
Licence
0.7
LGPL
020729
BSD
2.1.5
BSD
2.
GP
Li
Date dernière modification
Compatibilité Flash
17/03/2007
Action script S 3.0
29/07/2003
Flash 4, 5, Action ScriptAS : ?
03
Ac
Documentation 1
Outil fourni par l’API
Site internet
**
*
http://www.badgers-infoil.co.uk/projects/metaas/
http://www.anotherbigidea.com
/javaswf/
03/01/2007
Manipulation Flash7
Analyse et génère Flash9
***
Describe SWF
http://www.flagstonesoftware
.com/
Illustration 29 : Fiche récapitulative des API étudiées
1
Qualité de la documentation : * faible, *** fournie
Etude des API java pour la génération de code Flash - Page 54/59
**
De
ht
e.c
Probatoire CNAM 2007 – Nicolas Botet
IV.Conclusion
Quelles technologies choisir ? Il est vrai qu’Adobe propose un ensemble d’applications
fournissant un large éventail de possibilités aux développeurs désirant générer du code Flash.
Flash est un langage à part entière, propriétaire, nécessitant une bonne expérience et une
maîtrise des outils. Alors que la génération de code Flash à partir de java permet à des
développeurs java connaissant la description d’un fichier Flash de pouvoir générer du code
depuis un serveur ou développer des applications sous une licence libre.
D’un autre côté, l’utilisation de java pour la création d’applications utilisant des animations
ou une forte utilisation du graphisme semble montrer ses limites : d’une part pour les
développeurs, d’autre part en terme d’efficacité. De plus, java est fortement utilisé au niveau
serveur pour le développement d’application web ou pour le développement de logiciel.
Associer JAVA et Flash présente donc un avantage aux développeurs. Cependant, il existe
d’autres moyens de générer du Flash à partir d’autres outils que ceux proposés par Adobe.
Notamment en utilisant des outils de développement libre comme OpenLazlo ou comme
MTASC pour la compilation de code.
Concernant l’ensemble de ces API, il semble important de souligner que la création de fichier
SWF ainsi que leur modification semble efficace pour des développeurs Java. Néanmoins, il
semble plus complexe et moins pratique de travailler sur des fichiers créés par un autre moyen
que l’API utilisée. En effet, une bonne connaissance de la technologie Flash est nécessaire
afin d’appréhender le langage de balise et les actions pouvant être exécutées grâce au langage
Action Script.
Il semble également intéressant d’analyser la rentabilité d’utilisation de ces API. En effet,
même si le code Flash est évolutif et portable pour chacun de ses derniers lecteurs, Flash
évolue rapidement pour gagner en efficacité et rapidité. Les API Java ont-elles un avenir
quant à la motivation et l’engouement de ceux qui les créent ? Est-il intéressant d’utiliser ces
API quand il existe d’autres outils mis à disposition des développeurs et qu’adobe propose le
compilateur Flex en open source. L’avenir de Flash semble se tourner vers la solution Flex,
orienté client serveur et permettant la création d’application asynchrone dans un
environnement libre.
Etude des API java pour la génération de code Flash - Page 55/59
Probatoire CNAM 2007 – Nicolas Botet
V.Bibliographie

Adobe Flash : http://fr.wikipedia.org

Adobe : spécification du format de fichier SWF

Le format SWF : http://cerig.efpg.inpg.fr/dossierthe.labs.com

Flash : http://www.mediabox.fr

Flash : www.flashxpress.net

Flash : www.zoneflash.net

Informations sur Flash : http://flash.developpez.com

Informations sur Flash : http://the.labs.com

API Metaas : http://www.badgers-in-foil.co.uk/projects/metaas

API Java SWF2 : http://www.anotherbigidea.com/javaswf

Flagstone software : www.flagstonesofware.com

API Flagstone Transform SWF : http://www.flagstonesoftware.com

API jswiff : http://www.jswiff.com

Divers définitions : http://fr.wikipedia.org

Critiques :
les.html

Architecture des SI : http://jl2tho.blogspot.com
http://jurassicgeek.blogspot.com/2007/02/java-nest-pas-la-solution-tous-
Etude des API java pour la génération de code Flash - Page 56/59
Probatoire CNAM 2007 – Nicolas Botet
ANNEXE I : Rappel sur les licences utilisées dans cette étude
GNU LGPL (GNU Lesser General Public License)
Cette licence, dont la dernière version est la 3, est rédigée par la Free Software Foundation
dans le but de promouvoir le logiciel libre.
Elle permet de pouvoir utiliser une bibliothèque tierce sans qu’elle hérite de la licence LGPL.
Un logiciel propriétaire pourra alors utiliser ce type de licence sans que son code devienne
une licence LGPL.
Cependant, toute modification d’un code source sous licence LGPL entrainera un produit fini
sous licence LGPL.
GNU GPL (GNU General Public License)
Cette licence, dont la dernière version est la 3, est rédigée par la Free Software Foundation
afin de pouvoir réutiliser du code dans un logiciel libre ou propriétaire. Son utilisation peut
servir à des logiciels commerciaux ou non. En cas de distribution, le développeur devra
fournir le code source de la version modifiée et souscrire à une licence GPL.
BSD (Berkeley Software Distribution License)
Cette licence est l’une des moins restrictives dans le monde informatique et s’approche de la
notion de « domaine public ». Le code sous cette licence peut être publié sous licence GPL.
L’inverse n’est pas possible sans l’autorisation des auteurs car la licence GPL est plus
restrictive.
Etude des API java pour la génération de code Flash - Page 57/59
Probatoire CNAM 2007 – Nicolas Botet
Flagstone Software License
(Version 1, April 2001)
1. Definitions
1.1 "Licenced Software" means the code and documentation and other materials accompanying this License.
1.3 "You" or "Your" means an individual or a legal entity exercising rights under this License. For legal entities,
"You" or "Your" includes any entity which controls, is controlled by, or is under common control with, You,
where "control" means (a) the power, direct or indirect, to cause the direction or management of such entity,
whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or
beneficial ownership of such entity.
2. License.
Subject to the terms and conditions of this License, Flagstone Software Limited ("Flagstone") hereby grants you
a world-wide, royalty-free, non-exclusive license to do the following:
2.1 As an individual you may make and use copies of the Licenced Software for the purpose of designing and
developing your software product(s) provided that you are the only inidividual using the Licenced Software.
As an entity or organization you may make and use copies of the Licenced Softwareprovided that you have
acquired a separate and valid license for each each individual using the Licenced Software.
2.2 You may also store or install a copy of the Licenced Software on a network server only to install or run the
Licenced Software on computers used by a licenced end user. A single licence may not be shared or used
concurrently by other end users.
2.3 You may not translate, adapt, de-compile, reverse engineer or modify the Licenced Software.
2.4 You may reproduce and distribute the object code from any portion of the Licenced Software only as part of
a derivative work.
2.5 You may transfer your rights under this License provided you transfer this License and a copy of the
Software to a party who agrees to accept the terms of this License and destroy any other copies of the Software
in your possession.
3. Disclaimer of Warranties.
The Software is provided "AS IS" and without warranty of any kind. You acknowledge and agree that the use of
the Licenced Software is at your sole risk. FLAGSTONE DISCLAIMS ALL WARRANTIES, EXPRESSED
OR IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT OF
THIRD PARTY RIGHTS.
FLAGSTONE DOES NOT WARRANT THAT THE USE OR THE RESULTS OF THE USE OF THE
LICENSED SOFTWARE WILL BE UNINTERRUPTED OR ERROR FREE. SHOULD THE LICENSED
SOFTWARE PROVE DEFECTIVE, YOU (AND NOT FLAGSTONE) ASSUME THE ENTIRE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION. Some countries do not allow the exclusion of
implied warranties therefore the above disclaimer may not apply to you.
4. Limitation of Liability.
UNDER NO CIRCUMSTANCES SHALL FLAGSTONE BE LIABLE FOR ANY INCIDENTAL, SPECIAL,
INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF OR THE INABILITY TO
USE THIS LICENSED SOFTWARE. Some countries do not allow the exclusion or limitation of liability for
consequential or incidental damages so the above disclaimer may not apply to you.
Etude des API java pour la génération de code Flash - Page 58/59
Probatoire CNAM 2007 – Nicolas Botet
5. Termination.
5.1 Termination. This License and the rights granted hereunder will terminate:
(a) automatically without notice from Flagstone if You fail to comply with any term(s) of this License and fail to
cure such breach within 30 days of becoming aware of such breach;
(b) immediately in the event of the circumstances described in Section 7.3(b); or
(c) automatically without notice from Flagstone if You, at any time during the term of this License, commence
an action for patent infringement against Flagstone.
5.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, and
distribution of the Licenced Software and to destroy all copies of the Licenced Software that are in Your
possession or control.
6. Export Law.
You expressly agree to comply with all rules, regulations and laws applicable to the export or re-export of the
Licenced Software except as authorized by the laws of the United Kingdom or any jurisdiction in which the
Licenced Software was obtained. The Licenced Software may not be exported or re-exported into, or to a
national or resident of, any country embargoed by the United Kingdom. By using the Licenced Software, you
represent and warrant that you are not located in, under control of, or a national or resident of any such country
or on any such list.
7. Miscellaneous.
7.1 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture
or any other form of legal association between You and Flagstone, and You will not represent to the contrary,
whether expressly, by implication, appearance or otherwise.
7.2 Waiver; Construction. Failure by Flagstone to enforce any provision of this License will not be deemed a
waiver of future enforcement of that or any other provision. Any law or regulation which provides that the
language of a contract shall be construed against the drafter will not apply to this License.
7.3 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or
portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent
permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will
continue in full force and effect.
(b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically
complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will
immediately terminate and You must immediately discontinue any use of the Licenced Software and destroy all
copies of it that are in your possession or control.
7.4 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with
respect to the subject matter hereof. This License shall be governed by the laws of Scotland.
Etude des API java pour la génération de code Flash - Page 59/59