ADOBE Air Création d’applications [fr]

Download

Création d’applications

ADOBE®

AIR®

Informations juridiques

Vous trouverez des informations juridiques à l’adresse http://help.adobe.com/fr_FR/legalnotices/index.html.

Dernière mise à jour le 14/11/2013

Sommaire

Chapitre 1 : A propos d’Adobe AIR

Chapitre 2 : Installation d’Adobe AIR

Installation d’Adobe AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Désinstallation d’Adobe AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Installation et exécution des exemples d’application AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Mises à jour d’Adobe Air . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Chapitre 3 : Utilisation des API AIR

Classes ActionScript 3.0 propres à AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Classes Flash Player contenant des fonctionnalités propres à AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Composants Flex propres à AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

Chapitre 4 : Outils de la plate-forme Adobe Flash pour le développement AIR

Installation du kit de développement SDK AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Configuration du kit SDK Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Configuration de kits SDK externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

iii

Chapitre 5 : Création d’une première application AIR

Création d’une première application de bureau AIR Flex dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Création d’une première application de bureau AIR dans Flash Professional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Création d’une première application AIR for Android dans Flash Professional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Création d’une première application AIR for iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Création d’une première application AIR de type HTML dans Dreamweaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Création d’une première application AIR de type HTML à l’aide du kit SDK d’AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Création d’une première application de bureau AIR à l’aide du kit SDK de Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Création d’une première application AIR for Android à l’aide du kit SDK de Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

Chapitre 6 : Développement d’applications de bureau AIR

Flux de travail de développement d’une application de bureau AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Définition des propriétés d’une application de bureau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

Débogage d’une application de bureau AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

Mise en package d’un fichier d’installation AIR de bureau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

Mise en package d’un programme d’installation natif de bureau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

Mise en package d’un paquet de moteur d’exécution captif pour des ordinateurs de bureau . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Distribution d’un package AIR pour ordinateur de bureau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

Chapitre 7 : Développement d’applications AIR pour périphériques mobiles

Configuration de l’environnement de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Considérations liées à la conception d’applications mobiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Flux de travail de création d’une application AIR pour périphériques mobiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Définition des propriétés d’une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

Mise en package d’une application AIR mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Débogage d’une application AIR mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Sommaire

Installation d’AIR et d’applications AIR sur un périphérique mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Mise à jour des applications AIR mobiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

Utilisation des notifications Push . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

Chapitre 8 : Développement d’applications AIR pour périphériques TV

Fonctionnalités AIR propres aux téléviseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

Considérations à prendre en compte lors de la création d’une application AIR pour TV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

Flux de travail de développement d’une application AIR pour TV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

Propriétés du descripteur de l’application AIR pour TV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Mise en package d’une application AIR pour TV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Débogage d’applications AIR pour TV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

Chapitre 9 : Utilisation d’extensions natives pour Adobe AIR

Fichiers AIR Native Extension (ANE) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

Extensions natives ou classe NativeProcess ActionScript ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

Extensions natives ou bibliothèques de classes ActionScript (fichiers SWC) ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

Périphériques pris en charge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

Profils de périphérique pris en charge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

Liste de tâches pour l’utilisation d’une extension native . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

Déclaration de l’extension dans le fichier descripteur de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

Ajout du fichier ANE au chemin d’accès à la bibliothèque de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Mise en package d’une application faisant appel à des extensions natives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

Chapitre 10 : Compilateurs ActionScript

Présentation des outils de ligne de commande d’AIR intégrés au kit SDK Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

Configuration des compilateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

Compilation de fichiers sources MXML et ActionScript pour AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

Compilation d’un composant ou d’une bibliothèque de code AIR (Flex) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

Chapitre 11 : Application de débogage du lanceur AIR (ADL)

Utilisation de l’application ADL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

Exemples ADL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

Codes d’erreur et de sortie d’ADL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

Chapitre 12 : Outil AIR Developer (ADT)

Commandes de l’outil ADT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

Ensembles d’options ADT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

Messages d’erreur du programme ADT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

Variables d’environnement ADT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

Chapitre 13 : Signature d’applications AIR

Signature numérique d’un fichier AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

Création d’un fichier AIR intermédiaire non signé à l’aide de l’outil ADT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

Signature d’un fichier intermédiaire AIR à l’aide de l’outil ADT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

Signature d’une version mise à jour d’une application AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

Création d’un certificat auto-signé à l’aide de l’outil ADT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Sommaire

Chapitre 14 : Fichiers descripteurs d’applications AIR

Modifications apportées au fichier descripteur d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

Structure du fichier descripteur d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

Eléments du fichier descripteur d’application AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

Chapitre 15 : Profils de périphérique

Limitation des profils cible dans le fichier descripteur de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

Fonctionnalités des différents profils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

Chapitre 16 : API intégrée au navigateur et stockée dans le fichier AIR.SWF

Personnalisation du fichier badge.swf de l’installation transparente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

Utilisation du fichier badge.swf pour installer une application AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

Chargement du fichier air.swf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

Vérification de la présence du moteur d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

Vérification à partir d’une page Web de la présence d’une application AIR installée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

Installation d’une application AIR à partir du navigateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

Lancement d’une application AIR installée à partir du navigateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

Chapitre 17 : Mise à jour des applications AIR

A propos de la mise à jour des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270

Présentation d’une interface utilisateur personnalisée pour la mise à jour d’applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

Téléchargement d’un fichier AIR sur l’ordinateur de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

Vérifications permettant de savoir si l’application est exécutée pour la première fois . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

Utilisation de la structure de mise à jour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

Chapitre 18 : Affichage du code source

Chargement, configuration et ouverture de Source Viewer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

Interface utilisateur de Source Viewer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293

Chapitre 19 : Débogage à l’aide de l’outil AIR HTML Introspector

Présentation de l’outil AIR HTML Introspector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

Chargement du code de l’outil AIR HTML Introspector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

Inspection d’un objet dans l’onglet Console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

Configuration de l’outil AIR HTML Introspector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

Interface de l’outil AIR HTML Introspector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

Utilisation de l’outil AIR HTML Introspector avec du contenu d’un sandbox hors application . . . . . . . . . . . . . . . . . . . . . . . . . . . 303

Chapitre 20 : Localisation d’applications AIR

Localisation du nom et de la description de l’application dans le programme d’installation de l’application d’AIR . . . . . . . 306

Localisation de contenu HTML à l’aide de la structure de localisation HTML d’AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

Chapitre 21 : Variables d’environnement path

Définition de PATH sous Linux et Mac OS à l’aide de l’interface de commande Bash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

Définition de la variable d’environnement path sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

Dernière mise à jour le 14/11/2013

Chapitre 1 : A propos d’Adobe AIR

Adobe® AIR® est un moteur d’exécution gérant plusieurs systèmes d’exploitation et écrans, qui permet d’exploiter vos compétences en matière de développement Web pour développer et déployer des applications Internet enrichies (RIA) destinées aux ordinateurs de bureau et périphériques mobiles. Vous pouvez créer des applications AIR de bureau, pour télévisions et périphériques mobiles en ActionScript 3.0 à l’aide d’Adobe® Flex et d’Adobe® Flash® (type SWF). Vous pouvez également créer des applications AIR de bureau par le biais de HTML, JavaScript® et Ajax (type HTML).

Pour plus d’informations sur la prise en main et l’utilisation d’Adobe AIR, voir le site Adobe AIR Developer Connection (http://www.adobe.com/devnet/air/).

AIR permet de travailler dans des environnements qui vous sont familiers, ainsi que d’exploiter les outils et approches qui vous conviennent. La prise en charge de Flex, HTML, JavaScript et Ajax assure la création d’une solution optimale qui répond à vos besoins.

Vous pouvez par exemple développer des applications qui font appel à l’une des technologies suivantes ou à une combinaison de celles-ci :

• Flash / Flex / ActionScript

• HTML / JavaScript / CSS / Ajax

Les utilisateurs manipulent les applications AIR comme toute application native. Le moteur d’exécution est installé une seule fois sur l’ordinateur ou le périphérique de l’utilisateur. Il est alors possible d’installer et d’exécuter les applications AIR à l’instar de toute autre application de bureau. (Sous iOS, étant donné que chaque application AIR est autonome, aucun moteur d’exécution d’AIR n’est installé.)

Quel que soit le système d’exploitation utilisé, le moteur d’exécution propose une plate-forme et une structure uniformes de déploiement d’applications. La cohérence des fonctionnalités et interactions rend ainsi superflus les tests dans plusieurs navigateurs. Au lieu de développer une application pour un système d’exploitation déterminé, vous ciblez le moteur d’exécution. Cette approche offre les avantages suivants :

• Les applications développées pour AIR s’exécutent sur divers systèmes d’exploitation sans nécessiter d’intervention

supplémentaire de votre part. Le moteur d’exécution assure une présentation et des interactions cohérentes et prévisibles sur tous les systèmes d’exploitation pris en charge par AIR.

• Grâce à l’exploitation de technologies Web et de modèles de conception existants, la création d’applications est plus

rapide. Vous pouvez assurer la migration des applications Web vers le bureau sans avoir à apprendre les technologies traditionnelles de développement pour le bureau ou un code natif complexe.

• Parce qu’il ne fait pas appel à des langages de niveau inférieur tels que C et C++, le développement d’applications

s’en trouve simplifié. Il est ainsi inutile de gérer les API complexes de bas niveau propres à chaque système d’exploitation.

Développer des applications pour AIR vous permet d’exploiter un riche ensemble de structures et d’API :

• API propres à AIR proposées par le moteur d’exécution et la structure AIR

• API d’ActionScript utilisées par les fichiers SWF et la structure Flex (ainsi que qu’autres bibliothèques et structures

basées sur ActionScript)

• HTML, CSS et JavaScript

• La plupart des structures Ajax

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

A propos d’Adobe AIR

• Les extensions natives pour Adobe AIR fournissent des API ActionScript permettant d’accéder à des

fonctionnalités propres à la plate-forme programmées en code natif. Les extensions natives peuvent également permettre d’accéder au code natif hérité, ainsi qu’au code natif qui fournit de meilleures performances.

AIR a un impact considérable sur la création, le déploiement et l’utilisation des applications. Il vous assure un contrôle créatif accru et permet la migration des applications Flash, Flex, HTML et Ajax vers le bureau, les périphériques mobiles et les télévisions.

Pour plus d’informations sur le contenu de chaque nouvelle mise à jour d’AIR, voir les notes de mise à jour sur Adobe AIR (http://www.adobe.com/go/learn_air_relnotes_fr).

Dernière mise à jour le 14/11/2013

Chapitre 2 : Installation d’Adobe AIR

Le moteur d’exécution d’Adobe® AIR® permet d’exécuter des applications AIR. Pour installer le moteur d’exécution, procédez comme suit, au choix :

• Installez le moteur d’exécution séparément (sans installer d’application AIR).

• Installez une application AIR pour la première fois par le biais d’un « badge » d’installation de page Web (vous êtes

également invité à installer le moteur d’exécution).

• Créez un programme d’installation personnalisé qui installe votre application et le moteur d’exécution. Vous devez

demander l’autorisation de distribuer le moteur d’exécution AIR à Adobe. Pour demander l’autorisation, consulter la page Distribution du moteur d’exécution Adobe AIR. Notez qu’Adobe ne fournit aucun outil pour créer un tel programme d’installation. De nombreux kits d’outils tiers sont néanmoins disponibles.

• Installez une application AIR qui intègre AIR en tant que moteur d’exécution captif. Un moteur d’exécution natif

est utilisé uniquement par l’application de mise en paquet. Il n’est pas utilisé pour exécuter d’autres applications AIR. Le regroupement du moteur d’exécution est possible sur Mac et Windows. Sur iOS, toutes les applications incluent un moteur d’exécution intégré. A partir d’AIR 3.7, les applications Android incluent un moteur d’exécution intégré par défaut (même si vous pouvez utiliser un moteur d’exécution distinct).

• Configurez un environnement de développement AIR tel que le kit SDK AIR, Adobe® Flash® Builder™ ou le kit SDK

Adobe Flex® (qui contient les outils de développement de ligne de commande AIR). Le moteur d’exécution intégré au kit SDK est réservé au débogage d’applications, et non à l’exécution d’applications AIR installées.

Vous trouverez la configuration requise pour l’installation d’AIR et l’exécution d’applications AIR dans le document :

Adobe AIR : Configuration requise (http://www.adobe.com/fr/products/air/systemreqs/).

Le programme d’installation du moteur d’exécution et celui de l’application AIR créent des fichiers journaux lors de l’installation, la mise à jour ou la suppression de l’application ou du moteur d’exécution. Vous pouvez consulter ces journaux pour déterminer la cause de tout problème d’installation. Voir Installation logs.

Installation d’Adobe AIR

Pour installer ou mettre à jour le moteur d’exécution, l’utilisateur doit disposer de privilèges d’administration sur l’ordinateur.

Installation du moteur d’exécution sur un ordinateur Windows

1 Téléchargez le fichier d’installation du moteur d’exécution à partir de http://get.adobe.com/fr/air.

2 Double-cliquez sur le fichier d’installation du moteur d’exécution.

3 Dans la fenêtre d’installation, suivez les invites pour achever l’installation.

Installation du moteur d’exécution sur un ordinateur Mac

1 Téléchargez le fichier d’installation du moteur d’exécution à partir de http://get.adobe.com/fr/air.

2 Double-cliquez sur le fichier d’installation du moteur d’exécution.

3 Dans la fenêtre d’installation, suivez les invites pour achever l’installation.

4 Si le programme d’installation affiche une fenêtre d’authentification, entrez votre nom d’utilisateur et votre mot de

passe Mac OS.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Installation d’Adobe AIR

Installation du moteur d’exécution sur un ordinateur Linux

Remarque : actuellement, AIR 2.7 et les versions ultérieures ne sont pas prises en charge sur Linux. Les applications AIR déployées sur Linux doivent continuer d’utiliser le kit SDK d’AIR 2.6.

Utilisation du programme d’installation binaire :

1 Accédez au fichier d’installation binaire à l’adresse http://kb2.adobe.com/cps/853/cpsid_85304.html et téléchargez-

le.

2 Définissez les autorisations du fichier de sorte que le programme d’installation puisse être exécuté : Vous pouvez

définir les autorisations sur une ligne de commande, comme suit :

chmod +x AdobeAIRInstaller.bin

Certaines versions de Linux vous permettent de définir les autorisations des fichiers dans la boîte de dialogue Propriétés, ouverte par l’intermédiaire d’un menu contextuel.

3 Exécutez le programme d’installation à partir de la ligne de commande ou en double-cliquant sur le fichier

d’installation du moteur d’exécution.

4 Dans la fenêtre d’installation, suivez les invites pour achever l’installation.

Adobe AIR est installé sous forme de package natif. En d’autres termes, en tant que rpm sur une distribution de type rpm et en tant que deb sur une distribution Debian. AIR ne prend actuellement en charge aucun autre format de package.

Utilisation des programmes d’installation de package :

1 Accédez au fichier du package AIR à l’adresse http://kb2.adobe.com/cps/853/cpsid_85304.html. Téléchargez le

package rpm ou Debian, selon le format pris en charge par votre système.

2 Si nécessaire, double-cliquez sur le fichier de package d’AIR pour installer le package.

Vous pouvez également effectuer l’installation à partir la ligne de commande :

a Sur un système Debian :

sudo dpkg -i <path to the package>/adobeair-2.0.0.xxxxx.deb

b Sur un système rpm :

sudo rpm -i <path to the package>/adobeair-2.0.0-xxxxx.i386.rpm

Ou si vous mettez à jour une version existante (AIR 1.5.3 ou ultérieur) :

sudo rpm -U <path to the package>/adobeair-2.0.0-xxxxx.i386.rpm

Pour installer AIR 2 et les applications AIR, vous devez disposer de privilèges de niveau administrateur sur l’ordinateur.

Adobe AIR est installé à l’emplacement suivant : /opt/Adobe AIR/Versions/1.0

AIR enregistre le type mime « application/vnd.adobe.air-application-installer-package+zip », ce qui signifie que les fichiers .air correspondent à ce type mime et sont donc associés au moteur d’exécution d’AIR.

Installation du moteur d’exécution sur un périphérique Android

Vous pouvez installer la version la plus récente du moteur d’exécution d’AIR à partir d’Android Market.

Vous pouvez installer des versions de développement du moteur d’exécution d’AIR à partir d’un lien de page Web ou à l’aide de la commande ADT

-installRuntime. Il est possible d’installer une seule version du moteur d’exécution

d’AIR à la fois. En d’autres termes, une version validée ne peut pas cohabiter avec une version de développement.

Pour plus d’informations, voir « Commande ADT installRuntime » à la page 185.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Installation d’Adobe AIR

Installation du moteur d’exécution sur un périphérique iOS

Le code du moteur d’exécution d’AIR requis est intégré à chaque application pour périphériques iPhone, iTouch et iPad. Il est inutile d’installer un composant d’exécution distinct.

Voir aussi

« AIR for iOS » à la page 73

Désinstallation d’Adobe AIR

Après l’installation du moteur d’exécution, les procédures suivantes permettent de le désinstaller.

Désinstallation du moteur d’exécution sur un ordinateur Windows

1 Dans le menu Démarrer de Windows, sélectionnez Paramètres > Panneau de configuration.

2 Selon la version de Windows dont vous disposez, ouvrez l’élément du Panneau de configuration intitulé

Programmes, Programmes et fonctionnalités ou Ajout ou suppression de programmes.

3 Pour désinstaller le moteur d’exécution, sélectionnez « Adobe AIR ».

4 Cliquez sur le bouton Modifier/Supprimer.

Désinstallation du moteur d’exécution sur un ordinateur Mac

• Double-cliquez sur le programme de désinstallation d’Adobe AIR, situé dans le dossier /Applications/Utilities.

Désinstallation du moteur d’exécution sur un ordinateur Linux

Effectuez l’une des opérations suivantes :

• Sélectionnez la commande « Programme de désinstallation d’Adobe AIR » dans le menu Applications.

• Exécutez le programme d’installation binaire d’AIR avec l’option -uninstall.

• Supprimez les packages AIR (adobeair et adobecerts) avec le gestionnaire de package.

Suppression du moteur d’exécution sur un périphérique Android

1 Ouvrez l’application Réglages sur le périphérique.

2 Touchez l’entrée Adobe AIR sous Applications > Gérer les applications.

3 Touchez le bouton Désinstaller.

Vous disposez également de la commande ADT

ADT uninstallRuntime » à la page 186.

Suppression d’un moteur d’exécution intégré

Pour supprimer un programme d’exécution captif intégré, vous devez supprimer l’application avec laquelle il est installé. Notez que les moteurs d’exécution captifs sont utilisés uniquement pour exécuter l’application d’installation.

-uninstallRuntime. Pour plus d’informations, voir « Commande

Installation et exécution des exemples d’application AIR

Pour installer ou mettre à jour une application AIR, l’utilisateur doit disposer de privilèges d’administration sur l’ordinateur.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Installation d’Adobe AIR

Certains exemples d’application illustrent des fonctionnalités AIR. Procédez comme suit pour y accéder et les installer :

1 Téléchargez et exécutez les exemples d’application AIR. Les applications compilées et le code source sont

disponibles.

2 Pour télécharger et exécuter un exemple d’application, cliquez sur le bouton Installer maintenant proposé. Vous

êtes invité à installer et exécuter l’application.

3 Si vous décidez de télécharger des exemples d’application et de les exécuter ultérieurement, sélectionnez les liens de

téléchargement. Vous pouvez à tout moment exécuter une application AIR en procédant comme suit :

• Sous Windows, double-cliquez sur l’icône de l’application sur le bureau ou sélectionnez-la dans le menu

Démarrer de Windows.

• Sous Mac OS, double-cliquez sur l’icône de l’application, qui est installée par défaut dans le dossier Applications

de votre répertoire utilisateur (tel que Macintosh HD/Users/Jean/Applications/).

Remarque : pour vérifier si ces instructions ont été mises à jour, voir les Notes de parution d’AIR, qui résident à l’adresse suivante : http://www.adobe.com/go/learn_air_relnotes_fr.

Mises à jour d’Adobe Air

Adobe met régulièrement Adobe AIR à jour pour ajouter de nouvelles fonctionnalités ou corriger des problèmes mineurs. La fonction de notification et de mise à jour automatiques permet à Adobe d’avertir automatiquement les utilisateurs de la disponibilité d’une version mise à jour d’Adobe AIR.

Les mises à jour d’Adobe AIR garantissent que ce produit fonctionne correctement et contiennent souvent d’importantes modifications liées à la sécurité. Adobe recommande d’effectuer la mise à jour vers toute nouvelle version disponible d’Adobe AIR, surtout lorsqu’elle affecte la sécurité.

Au lancement d’une application AIR, le moteur d’exécution vérifie par défaut la disponibilité d’une mise à jour. Il effectue cette opération si la dernière vérification remonte à plus de deux semaines. Si une mise à jour est disponible, AIR la télécharge en arrière-plan.

Il est possible de désactiver la fonction de mise à jour automatique à l’aide de l’application AIR SettingsManager. Cette application peut être téléchargée à partir de

http://airdownload.adobe.com/air/applications/SettingsManager/SettingsManager.air.

Le processus d’installation standard d’Adobe AIR se connecte à http://airinstall.adobe.com pour envoyer des informations de base sur l’environnement d’installation, notamment la version et la langue du système d’exploitation. Ces informations sont transmises une seule fois par installation et permettent à Adobe de confirmer que l’installation a abouti. Aucune information personnelle identifiable n’est collectée ou transmise.

Mise à jour des moteurs d’exécution captifs

Si vous distribuez votre application avec un paquet de moteur d’exécution captif, le moteur d’exécution captif n’est pas mis à jour automatiquement. Pour assurer la sécurité des utilisateurs, vous devez gérer les mises à jour publiées par Adobe et mettre à jour votre application avec la nouvelle version du moteur d’exécution lors de la publication d’une modification de sécurité importante.

Dernière mise à jour le 14/11/2013

Chapitre 3 : Utilisation des API AIR

Adobe® AIR® comprend des fonctionnalités dont ne dispose pas un contenu SWF qui s’exécute dans Adobe® Flash® Player.

Développeurs ActionScript 3.0

Les API Adobe AIR sont décrites dans les deux documents suivants :

• Guide du développeur ActionScript 3.0

• Guide de référence ActionScript 3.0 pour la plate-forme Adobe Flash

Développeurs HTML

Si vous créez des applications AIR de type HTML, les API disponibles en JavaScript via le fichier AIRAliases.js (voir

Accès aux classes de l’API AIR à partir de JavaScript) sont décrites dans les deux documents suivants :

• HTML Developer’s Guide for Adobe AIR

• Adobe AIR API Reference for HTML Developers

Classes ActionScript 3.0 propres à AIR

Le tableau suivant contient les classes d’exécution propres à Adobe AIR. Elles ne sont pas disponibles pour le contenu SWF s’exécutant dans Adobe® Flash® Player dans le navigateur.

Développeurs HTML

Les classes disponibles en JavaScript via le fichier AIRAliases.js sont décrites dans Adobe AIR API Reference for

HTML Developers (disponible en anglais uniquement).

Classe Package ActionScript 3.0 Ajoutée à la version AIR

ARecord flash.net.dns 2.0

AAAARecord flash.net.dns 2.0

ApplicationUpdater air.update 1.5

ApplicationUpdaterUI air.update 1.5

AudioPlaybackMode flash.media 3.0

AutoCapitalize flash.text 3.0

BrowserInvokeEvent flash.events 1.0

CameraPosition flash.media 3.0

CameraRoll flash.media 2.0

CameraRollBrowseOptions flash.media 3.0

CameraUI flash.media 2.5

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

Classe Package ActionScript 3.0 Ajoutée à la version AIR

CertificateStatus flash.security 2.0

CompressionAlgorithm flash.utils 1.0

DatagramSocket flash.net 2.0

DatagramSocketDataEvent flash.events 2.0

DNSResolver flash.net.dns 2.0

DNSResolverEvent flash.events 2.0

DockIcon flash.desktop 1.0

DownloadErrorEvent air.update.events 1.5

DRMAuthenticateEvent flash.events 1.0

DRMDeviceGroup flash.net.drm 3.0

DRMDeviceGroupErrorEvent flash.net.drm 3.0

DRMDeviceGroupEvent flash.net.drm 3.0

DRMManagerError flash.errors 1.5

EncryptedLocalStore flash.data 1.0

ExtensionContext flash.external 2.5

File flash.filesystem 1.0

FileListEvent flash.events 1.0

FileMode flash.filesystem 1.0

FileStream flash.filesystem 1.0

FocusDirection flash.display 1.0

GameInput flash.ui 3.0

GameInputControl flash.ui 3.0

GameInputControlType flash.ui 3.6 et versions antérieures ;

GameInputDevice flash.ui 3.0

GameInputEvent flash.ui 3.0

GameInputFinger flash.ui 3.6 et versions antérieures ;

GameInputHand flash.ui 3.6 et versions antérieures ;

abandonné à partir de la version 3.7

Geolocation flash.sensors 2.0

GeolocationEvent flash.events 2.0

HTMLHistoryItem flash.html 1.0

HTMLHost flash.html 1.0

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

Classe Package ActionScript 3.0 Ajoutée à la version AIR

HTMLLoader flash.html 1.0

HTMLPDFCapability flash.html 1.0

HTMLSWFCapabiltiy flash.html 2.0

HTMLUncaughtScriptExceptionEvent flash.events 1.0

HTMLWindowCreateOptions flash.html 1.0

Icon flash.desktop 1.0

IFilePromise flash.desktop 2.0

ImageDecodingPolicy flash.system 2.6

InteractiveIcon flash.desktop 1.0

InterfaceAddress flash.net 2.0

InvokeEvent flash.events 1.0

InvokeEventReason flash.desktop 1.5.1

IPVersion flash.net 2.0

IURIDereferencer flash.security 1.0

LocationChangeEvent flash.events 2.5

MediaEvent flash.events 2.5

MediaPromise flash.media 2.5

MediaType flash.media 2.5

MXRecord flash.net.dns 2.0

NativeApplication flash.desktop 1.0

NativeDragActions flash.desktop 1.0

NativeDragEvent flash.events 1.0

NativeDragManager flash.desktop 1.0

NativeDragOptions flash.desktop 1.0

NativeMenu flash.display 1.0

NativeMenuItem flash.display 1.0

NativeProcess flash.desktop 2.0

NativeProcessExitEvent flash.events 2.0

NativeProcessStartupInfo flash.desktop 2.0

NativeWindow flash.display 1.0

NativeWindowBoundsEvent flash.events 1.0

NativeWindowDisplayState flash.display 1.0

NativeWindowDisplayStateEvent flash.events 1.0

NativeWindowInitOptions flash.display 1.0

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

Classe Package ActionScript 3.0 Ajoutée à la version AIR

NativeWindowRenderMode flash.display 3.0

NativeWindowResize flash.display 1.0

NativeWindowSystemChrome flash.display 1.0

NativeWindowType flash.display 1.0

NetworkInfo flash.net 2.0

NetworkInterface flash.net 2.0

NotificationType flash.desktop 1.0

OutputProgressEvent flash.events 1.0

PaperSize flash.printing 2.0

PrintMethod flash.printing 2.0

PrintUIOptions flash.printing 2.0

PTRRecord flash.net.dns 2.0

ReferencesValidationSetting flash.security 1.0

ResourceRecord flash.net.dns 2.0

RevocationCheckSettings flash.security 1.0

Screen flash.display 1.0

ScreenMouseEvent flash.events 1.0

SecureSocket flash.net 2.0

SecureSocketMonitor air.net 2.0

ServerSocket flash.net 2.0

ServerSocketConnectEvent flash.events 2.0

ServiceMonitor air.net 1.0

SignatureStatus flash.security 1.0

SignerTrustSettings flash.security 1.0

SocketMonitor air.net 1.0

SoftKeyboardType flash.text 3.0

SQLCollationType flash.data 1.0

SQLColumnNameStyle flash.data 1.0

SQLColumnSchema flash.data 1.0

SQLConnection flash.data 1.0

SQLError flash.errors 1.0

SQLErrorEvent flash.events 1.0

SQLErrorOperation flash.errors 1.0

SQLEvent flash.events 1.0

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

Classe Package ActionScript 3.0 Ajoutée à la version AIR

SQLIndexSchema flash.data 1.0

SQLMode flash.data 1.0

SQLResult flash.data 1.0

SQLSchema flash.data 1.0

SQLSchemaResult flash.data 1.0

SQLStatement flash.data 1.0

SQLTableSchema flash.data 1.0

SQLTransactionLockType flash.data 1.0

SQLTriggerSchema flash.data 1.0

SQLUpdateEvent flash.events 1.0

SQLViewSchema flash.data 1.0

SRVRecord flash.net.dns 2.0

StageAspectRatio flash.display 2.0

StageOrientation flash.display 2.0

StageOrientationEvent flash.events 2.0

StageText flash.text 3.0

StageTextInitOptions flash.text 3.0

StageWebView flash.media 2.5

StatusFileUpdateErrorEvent air.update.events 1.5

StatusFileUpdateEvent air.update.events 1.5

StatusUpdateErrorEvent air.update.events 1.5

StatusUpdateEvent air.update.events 1.5

StorageVolume flash.filesystem 2.0

StorageVolumeChangeEvent flash.events 2.0

StorageVolumeInfo flash.filesystem 2.0

SystemIdleMode flash.desktop 2.0

SystemTrayIcon flash.desktop 1.0

TouchEventIntent flash.events 3.0

UpdateEvent air.update.events 1.5

Updater flash.desktop 1.0

URLFilePromise air.desktop 2.0

URLMonitor air.net 1.0

URLRequestDefaults flash.net 1.0

XMLSignatureValidator flash.security 1.0

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

Classes Flash Player contenant des fonctionnalités propres à AIR

Les classes suivantes sont disponibles pour les contenus SWF exécutés dans le navigateur, mais AIR offre des propriétés ou des méthodes supplémentaires :

Package Classe Propriété, méthode ou événement Ajoutée à la version

flash.desktop Clipboard supportsFilePromise 2.0

ClipboardFormats BITMAP_FORMAT 1.0

FILE_LIST_FORMAT 1.0

FILE_PROMISE_LIST_FORMAT 2.0

URL_FORMAT 1.0

flash.display LoaderInfo

Stage assignFocus() 1.0

childSandboxBridge 1.0

parentSandboxBridge 1.0

autoOrients 2.0

deviceOrientation 2.0

nativeWindow 1.0

orientation 2.0

Evénement orientationChange 2.0

Evénement orientationChanging 2.0

setAspectRatio 2.0

setOrientation 2.0

AIR

softKeyboardRect 2.6

supportedOrientations 2.6

supportsOrientationChange 2.0

NativeWindow owner 2.6

listOwnedWindows 2.6

NativeWindowInitOptions owner 2.6

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

Package Classe Propriété, méthode ou événement Ajoutée à la version

AIR

flash.events Event CLOSING 1.0

DISPLAYING 1.0

PREPARING 2.6

EXITING 1.0

HTML_BOUNDS_CHANGE 1.0

HTML_DOM_INITIALIZE 1.0

HTML_RENDER 1.0

LOCATION_CHANGE 1.0

NETWORK_CHANGE 1.0

STANDARD_ERROR_CLOSE 2.0

STANDARD_INPUT_CLOSE 2.0

STANDARD_OUTPUT_CLOSE 2.0

USER_IDLE 1.0

USER_PRESENT 1.0

HTTPStatusEvent

HTTP_RESPONSE_STATUS 1.0

responseHeaders 1.0

KeyboardEvent

responseURL 1.0

commandKey 1.0

controlKey 1.0

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

Package Classe Propriété, méthode ou événement Ajoutée à la version

AIR

flash.net FileReference extension 1.0

Evénement

uploadUnencoded() 1.0

NetStream Evénement

Evénement

preloadEmbeddedData() 1.5

resetDRMVouchers() 1.0

setDRMAuthenticationCredent ials()

httpResponseStatus 1.0

drmAuthenticate 1.0

onDRMContentData 1.5

1.0

URLRequest authenticate 1.0

cacheResponse 1.0

followRedirects 1.0

idleTimeout 2.0

manageCookies 1.0

useCache 1.0

userAgent 1.0

URLStream

événement httpResponseStatus

1.0

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

Package Classe Propriété, méthode ou événement Ajoutée à la version

flash.printing PrintJob active 2.0

copies 2.0

firstPage 2.0

isColor 2.0

jobName 2.0

lastPage 2.0

maxPixelsPerInch 2.0

paperArea 2.0

printableArea 2.0

printer 2.0

printers 2.0

selectPaperSize() 2.0

showPageSetupDialog() 2.0

start2() 2.0

supportsPageSetupDialog 2.0

terminate() 2.0

AIR

PrintJobOptions

flash.system Capabilities

LoaderContext

Security

flash.ui KeyLocation D_PAD 2.5

pixelsPerInch 2.0

printMethod 2.0

languages 1.1

allowLoadBytesCodeExecution 1.0

APPLICATION 1.0

La plupart de ces nouvelles propriétés et méthodes sont uniquement disponibles pour le contenu situé dans le sandbox de sécurité de l’application AIR. Toutefois, les nouveaux membres des classes URLRequest sont également disponibles pour le contenu exécuté dans d’autres sandbox.

Les méthodes

algorithm permettant de choisir entre les compressions deflate et zlib. Ce paramètre n’est disponible que pour le

ByteArray.compress() et ByteArray.uncompress() comprennent chacune un nouveau paramètre

contenu s’exécutant dans AIR.

Composants Flex propres à AIR

Les composants MX d’Adobe® Flex™ suivants sont disponibles lors du développement d’un contenu pour Adobe AIR :

• FileEvent

• FileSystemComboBox

• FileSystemDataGrid

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Utilisation des API AIR

• FileSystemEnumerationMode

• FileSystemHistoryButton

• FileSystemList

• FileSystemSizeDisplayMode

• FileSystemTree

• FlexNativeMenu

• HTML

• Window

• WindowedApplication

• WindowedSystemManager

Par ailleurs, Flex 4 comprend les composants AIR spark suivants :

• Window

• WindowedApplication

Pour plus d’informations sur les composants AIR Flex, voir Utilisation des composants AIR de Flex.

Dernière mise à jour le 14/11/2013

Chapitre 4 : Outils de la plate-forme Adobe Flash pour le développement AIR

Vous pouvez développer des applications AIR à l’aide des outils de développement suivants de la plate-forme Adobe Flash.

Développeurs ActionScript 3.0 (Flash et Flex) :

• Adobe Flash Professional (voir Publication pour AIR)

• Kit SDK d’Adobe Flex 3.x et 4.x (voir « Configuration du kit SDK Flex » à la page 19 et « Outil AIR Developer

(ADT) » à la page 173)

• Adobe Flash Builder (voir Développement d’applications AIR avec Flash Builder)

Développeurs HTML et Ajax :

• Kit de développement SDK Adobe AIR (voir « Installation du kit de développement SDK AIR » à la page 17 et

« Outil AIR Developer (ADT) » à la page 173)

• Adobe Dreamweaver CS3, CS4, CS5 (voir Extension AIR pour Dreamweaver)

Installation du kit de développement SDK AIR

Le kit de développement SDK AIR contient les outils de ligne de commande suivants, qui permettent de lancer et de mettre en package des applications :

Application de débogage du lanceur AIR (ADL) Permet de lancer des applications AIR sans devoir d’abord les installer.

Voir « Application de débogage du lanceur AIR (ADL) » à la page 167.

Outil AIR Developer (ADT) Met en package des applications AIR sous la forme de packages d’installation distribuables.

Voir « Outil AIR Developer (ADT) » à la page 173.

Les outils de ligne de commande d’AIR nécessitent l’installation de Java sur l’ordinateur. Vous pouvez utiliser la machine virtuelle Java à partir des environnements JRE ou JDK (version 1.5 ou ultérieure). Vous pouvez télécharger ces environnements à l’adresse suivante : http://java.sun.com/.

Vous devez disposer d’au moins 2 Go de mémoire pour exécuter l’outil ADT.

Remarque : l’utilisateur final n’a pas besoin de Java pour exécuter les applications AIR.

Pour consulter un aperçu rapide de la création d’une application AIR à l’aide du kit SDK d’AIR, voir « Création d’une

première application AIR de type HTML à l’aide du kit SDK d’AIR » à la page 34.

Téléchargement et installation du kit SDK AIR

Pour télécharger et installer le kit SDK AIR, procédez comme suit :

Installation du kit SDK AIR sous Windows

• Téléchargez le fichier d’installation du kit SDK AIR.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Outils de la plate-forme Adobe Flash pour le développement AIR

• Il est distribué sous la forme d’une archive de fichier standard. Pour installer AIR, extrayez le contenu du kit SDK

dans un dossier sur l’ordinateur (exemple : C:\Program Files\Adobe\AIRSDK ou C:\AIRSDK).

• Les outils ADL et ADT figurent dans le dossier bin du kit SDK AIR. Ajoutez le chemin de ce dossier à la variable

d’environnement PATH.

Installation du kit SDK AIR sous Mac OS X

• Téléchargez le fichier d’installation du kit SDK AIR.

• Il est distribué sous la forme d’une archive de fichier standard. Pour installer AIR, extrayez le contenu du kit SDK

dans un dossier sur l’ordinateur (exemple : /Users/<nomUtilisateur>/Applications/AIRSDK).

• Les outils ADL et ADT figurent dans le dossier bin du kit SDK AIR. Ajoutez le chemin de ce dossier à la variable

d’environnement PATH.

Installation du kit SDK AIR sous Linux

• Le kit SDK est disponible au format tbz2.

• Pour installer le kit SDK, créez un dossier pour le décompresser, puis entrez la commande suivante : tar -jxvf

Pour plus d’informations sur l’initiation aux outils du kit SDK AIR, voir Création d’une application AIR à l’aide des outils de ligne de commande.

Contenu du kit SDK AIR

Le tableau suivant décrit les fichiers que contient le kit SDK AIR :

Dossier du kit SDK Description des fichiers/outils

bin L’application de débogage du lanceur AIR (ADL) permet d’exécuter une application

frameworks Le répertoire libs contient des bibliothèques de code destinées aux applications AIR.

include Le répertoire include contient un fichier d’en-tête de langage C pour l’écriture

install Le répertoire install contient les pilotes USB Windows associés aux périphériques

lib Contient le code de prise en charge des outils du kit SDK d’AIR.

AIR sans la mettre en package et l’installer au préalable. Pour plus d’informations sur l’utilisation de cette application, voir « Application de débogage du lanceur AIR

(ADL) » à la page 167.

L’outil AIR Developer (ADT) met en package une application sous la forme d’un fichier AIR distribuable. Pour plus d’informations sur l’utilisation de cet outil, voir « Outil AIR

Developer (ADT) » à la page 173.

Le répertoire projects contient le code des bibliothèques SWF et SWC compilées.

d’extensions natives.

Android. (Ces pilotes sont fournis par Google dans le kit SDK d’Android.)

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Outils de la plate-forme Adobe Flash pour le développement AIR

Dossier du kit SDK Description des fichiers/outils

runtimes Moteurs d’exécution d’AIR destinés au bureau et aux périphériques mobiles.

L’application de débogage du lanceur AIR (ADL) utilise le moteur d’exécution pour lancer les applications AIR avant leur mise en package ou leur installation.

Vous pouvez installer les moteurs d’exécution d’AIR for Android (packages APK) sur des émulateurs ou des périphériques Android à des fins de développement ou de test. Utilisez un package APK distinct pour les périphériques et les émulateurs. (Vous pouvez télécharger le moteur d’exécution d’AIR for Android public à partir d’Android Market.)

samples Ce dossier contient un exemple de fichier descripteur d’application, un exemple de

templates descriptor-template.xml : modèle du fichier descripteur d’application, que requiert

fonction d’installation transparente (badge.swf) et les icônes d’application AIR par défaut.

chaque application AIR. Pour une description détaillée du fichier descripteur d’application, voir « Fichiers descripteurs d’applications AIR » à la page 215.

Ce dossier contient également les fichiers de schéma associés à la structure XML du fichier descripteur d’application de chaque version d’AIR.

Configuration du kit SDK Flex

Pour développer des applications Adobe® AIR® dans Adobe® Flex™, vous disposez des options suivantes :

• Vous pouvez télécharger et installer Adobe® Flash® Builder™, qui intègre des outils permettant de créer des projets

Adobe AIR, ainsi que de tester, déboguer et mettre en package les applications AIR. Voir « Création d’une première

application de bureau AIR Flex dans Flash Builder » à la page 21.

• Vous pouvez télécharger le kit SDK d’Adobe® Flex™ et développer des applications AIR Flex à l’aide de votre éditeur

de texte et de vos outils de ligne de commande favoris.

Pour consulter un aperçu rapide de la création d’une application AIR à l’aide du kit SDK de Flex, voir « Création d’une

première application de bureau AIR à l’aide du kit SDK de Flex » à la page 38.

Installation du kit SDK Flex

Pour pouvoir créer des applications AIR à l’aide des outils de ligne de commande, Java doit être installé sur l’ordinateur. Vous pouvez utiliser la machine virtuelle Java à partir des environnements JRE ou JDK (version 1.5 ou ultérieure). Vous pouvez télécharger ces environnements à l’adresse suivante : http://java.sun.com/.

Remarque : l’utilisateur final n’a pas besoin de Java pour exécuter les applications AIR.

Le kit SDK de Flex offre l’API d’AIR et les outils de ligne de commande nécessaires pour mettre en package, compiler et déboguer les applications AIR.

1 Le cas échéant, téléchargez le kit SDK Flex à partir de

http://opensource.adobe.com/wiki/display/flexsdk/Downloads.

2 Placez le contenu du kit SDK dans un dossier (Flex SDK, par exemple).

3 Copiez le contenu du kit SDK d’AIR sur les fichiers du kit SDK de Flex.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Outils de la plate-forme Adobe Flash pour le développement AIR

Remarque : sur un ordinateur Mac, veillez à copier ou remplacer les fichiers des dossiers du kit SDK, plutôt que des répertoires entiers. Par défaut, copier un répertoire sur un répertoire du même nom sur un ordinateur Mac supprime les fichiers existants du répertoire cible, plutôt que de fusionner le contenu des deux répertoires. Vous pouvez utiliser la commande

air_sdk_folder flex_sdk_folder

4 Les outils de ligne de commande AIR figurent dans le dossier bin.

ditto dans une fenêtre de terminal pour fusionner le kit SDK d’AIR et le kit SDK de Flex :ditto

Configuration de kits SDK externes

Le développement d’applications pour Android et iOS nécessite de télécharger des fichiers de configuration, des kits SDK et autres outils de développement à partir des éditeurs de la plate-forme.

Pour plus d’informations sur le téléchargement et l’installation du kit SDK d’Android, voir Android Developers :

Installing the SDK (disponible en anglais uniquement). Depuis AIR 2.6, il n’est plus obligatoire de télécharger le kit

SDK d’Android. Le kit SDK d’AIR comprend à présent les composants de base requis pour installer et lancer des packages APK. Le kit SDK d’Android s’avère toutefois utile pour diverses tâches de développement, notamment la création et l’exécution d’émulateurs logiciels, ainsi que la capture d’écrans de périphérique.

Le développement d’application iOS ne requiert pas de kit SDK externe. Vous devez toutefois disposer de certificats et fichiers de configuration spéciaux. Pour plus d’informations, voir Obtention de fichiers de développement auprès

d’Apple.

Dernière mise à jour le 14/11/2013

Chapitre 5 : Création d’une première application AIR

Création d’une première application de bureau AIR Flex dans Flash Builder

Pour vous familiariser rapidement avec le fonctionnement d’Adobe® AIR®, suivez les instructions ci-dessous, qui permettent de créer et de mettre en package une application AIR SWF simple, appelée « Hello World », à l’aide d’Adobe® Flash® Builder.

Le cas échéant, téléchargez et installez Flash Builder. Téléchargez et installez également la version la plus récente d’Adobe AIR à partir de l’adresse suivante : www.adobe.com/go/air_fr.

Création d’un projet AIR

Flash Builder propose des outils de développement et de mise en package d’applications AIR.

Pour créer une application AIR dans Flash Builder ou Flex Builder, vous commencez comme s’il s’agissait de tout autre projet d’application Flex, c-à-d. en définissant un nouveau projet.

1 Ouvrez Flash Builder.

2 Sélectionnez Fichier > Nouveau > Projet Flex.

3 Attribuez au projet le nom AIRHelloWorld.

4 Dans Flex, les applications AIR sont considérées comme un type d’application. Vous disposez de deux options de

type :

• Application Web qui s’exécute dans Adobe® Flash® Player

• Application de bureau qui s’exécute dans Adobe AIR

Sélectionnez le type d’application de bureau.

5 Cliquez sur Terminer pour créer le projet.

Les projets AIR se composent initialement de deux fichiers : le fichier MXML principal et un fichier XML d’application (ou fichier descripteur d’application). Le second fichier spécifie les propriétés d’une application.

Pour plus d’informations, voir Développement d’applications AIR avec Flash Builder.

Ecriture du code de l’application AIR

Pour écrire le code de l’application « Hello World », vous modifiez le fichier MXML de l’application, qui est ouvert dans l’éditeur. (Le cas échéant, ouvrez le fichier dans l’explorateur de projets.)

Les applications AIR Flex de bureau sont contenues dans la balise MXML WindowedApplication. Celle-ci crée une fenêtre simple qui comprend des contrôles de fenêtre de base, tels qu’une barre de titre et un bouton de fermeture.

1 Ajoutez un attribut title au composant WindowedApplication et affectez-lui la valeur "Hello World" :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

<?xml version="1.0" encoding="utf-8"?> <s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"

xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" title="Hello World">

</s:WindowedApplication>

2 Ajoutez un composant Label à l’application (en le plaçant dans la balise WindowedApplication). Définissez la

propriété

<?xml version="1.0" encoding="utf-8"?> <s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"

</s:WindowedApplication>

text du composant Label sur "Hello AIR" et stipulez qu’il doit être centré, comme illustré ci-dessous :

xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" title="Hello World">

<s:Label text="Hello AIR" horizontalCenter="0" verticalCenter="0"/>

3 Ajoutez le bloc de style suivant juste après la balise WindowedApplication d’ouverture et avant la balise du

composant Label que vous venez d’entrer :

<fx:Style>

@namespace s "library://ns.adobe.com/flex/spark"; s|WindowedApplication {

skinClass:ClassReference("spark.skins.spark.SparkChromeWindowedApplicationSkin");

background-color:#999999; background-alpha:"0.7";

}

</fx:Style>

Ces paramètres de style s’appliquent à l’intégralité de l’application et définissent un arrière-plan de fenêtre gris légèrement transparent.

Le code de l’application se présente à présent comme suit :

<?xml version="1.0" encoding="utf-8"?> <s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"

xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" title="Hello World">

<fx:Style>

@namespace s "library://ns.adobe.com/flex/spark"; s|WindowedApplication {

skinClass:ClassReference("spark.skins.spark.SparkChromeWindowedApplicationSkin");

background-color:#999999; background-alpha:"0.7";

}

</fx:Style>

<s:Label text="Hello AIR" horizontalCenter="0" verticalCenter="0"/>

</s:WindowedApplication>

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Vous allez maintenant modifier certains paramètres dans le descripteur de l’application pour que celle-ci soit transparente :

1 Dans le panneau Navigation de Flex, recherchez le fichier descripteur d’application dans le répertoire source du

projet. Si vous avez nommé le projet AIRHelloWorld, ce fichier s’appelle AIRHelloWorld-app.xml.

2 Double-cliquez sur le fichier descripteur d’application pour le modifier dans Flash Builder.

3 Dans le code XML, recherchez les lignes de commentaire des propriétés systemChrome et transparent (de la

propriété

« --> »).

4 Définissez la valeur de texte de la propriété systemChrome sur none, comme indiqué ci-après :

5 Définissez la valeur de texte de la propriété transparent sur true, comme indiqué ci-après :

6 Enregistrez le fichier.

initialWindow). Supprimez les commentaires (autrement dit, supprimez les séparateurs « <!-- » et

Test de l’application AIR

Pour tester le code d’application que vous venez d’écrire, exécutez-le en mode de débogage.

1 Cliquez sur le bouton de débogage dans la barre d’outils principale.

Vous pouvez aussi sélectionner la commande Run > Debug > AIRHelloWorld.

L’application AIR qui en résulte s’apparente à l’exemple suivant :

2 Grâce aux propriétés horizontalCenter et verticalCenter du contrôle Label, le texte est placé au centre de la

fenêtre. Vous pouvez déplacer ou redimensionner la fenêtre comme pour toute autre application de bureau.

Remarque : si la compilation de l’application échoue, corrigez les erreurs de syntaxe ou les fautes d’orthographe introduites par inadvertance dans le code. Dans Flash Builder, les erreurs et les avertissements s’affichent en mode Problems.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Mise en package, signature et exécution de l’application AIR

Vous pouvez maintenant mettre l’application « Hello World » en package sous forme de fichier AIR pour la distribuer. Un fichier AIR est un fichier d’archives contenant les fichiers de l’application ; autrement dit, tous les fichiers qui figurent dans le dossier bin du projet. Dans cet exemple simple, il s’agit des fichiers SWF et XML. Vous distribuez le package AIR aux utilisateurs, qui s’en servent pour installer l’application. Dans le cadre de ce processus, il est impératif de signer le package numériquement.

1 Assurez-vous que l’application est exempte d’erreurs de compilation et s’exécute comme il se doit.

2 Sélectionnez Projet > Exporter vers une version validée.

3 Vérifiez que le projet correspond à AIRHelloWorld et l’application à AIRHelloWorld.mxml.

4 Sélectionnez l’option d’exportation en tant que package signé. Cliquez ensuite sur Suivant.

5 Si vous disposez déjà d’un certificat numérique, cliquez sur Parcourir pour y accéder, puis sélectionnez-le.

6 Si vous devez créer un certificat numérique auto-signé, sélectionnez Créer.

7 Spécifiez les informations requises et cliquez sur OK.

8 Cliquez sur Terminer pour générer le package AIR, qui s’appelle AIRHelloWorld.air.

Vous pouvez maintenant installer et exécuter l’application à partir de l’explorateur de projets dans Flash Builder ou en double-cliquant sur le fichier AIR dans le système de fichiers.

Création d’une première application de bureau AIR dans Flash Professional

Cette rubrique propose une brève démonstration pratique du fonctionnement d’Adobe® AIR® en vous aidant à créer et à mettre en package une application AIR simple nommée « Hello World » à l’aide d’Adobe® Flash® Professional.

Le cas échéant, téléchargez et installez Adobe AIR, à l’adresse suivante : www.adobe.com/go/air_fr.

Création de l’application Hello World dans Flash

La création d’une application Adobe AIR dans Flash ressemble beaucoup à la création d’un autre fichier FLA. La procédure suivante vous guide tout au long du processus de création de l’application Hello World simple avec Flash Professional.

Pour créer l’application Hello World

1 Démarrez Flash.

2 Dans l’écran de bienvenue, cliquez sur AIR pour créer un fichier FLA vide avec les paramètres de publication

d’Adobe AIR.

3 Sélectionnez l’outil Texte dans le panneau Outils et créez un champ de texte statique (par défaut) au centre de la

scène. Choisissez une largeur pouvant contenir 15 à 20 caractères.

4 Entrez le texte « Hello World » dans le champ.

5 Enregistrez le fichier en lui donnant un nom (HelloAIR, par exemple).

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Test de l’application

1 Appuyez sur Ctrl + Entrée ou sélectionnez Contrôle > Tester l’animation > Tester pour tester l’application dans

Adobe AIR.

2 Pour utiliser la fonction Déboguer l’animation, ajoutez d’abord du code ActionScript à l’application. Vous pouvez

le faire rapidement en ajoutant une instruction trace telle que :

trace("Running AIR application using Debug Movie");

3 Appuyez sur Ctrl + Maj + Entrée ou sélectionnez Déboguer > Déboguer l’animation > Déboguer pour exécuter

l’application avec Déboguer l’animation.

L’application Hello World ressemble à l’illustration suivante :

Mise en package de l’application

1 Sélectionnez Fichier > Publier.

2 Signez le package Adobe AIR à l’aide d’un certificat numérique existant ou créez un certificat auto-signé en

procédant comme suit :

a Cliquez sur le bouton Créer en regard du champ Certificat.

b Renseignez les entrées Nom de l’éditeur, Unité d’organisation, Nom de l’organisation, E-mail, Pays, Mot de

passe et Confirmer le mot de passe.

c Spécifiez le type de certificat. L’option Type du certificat fait référence au niveau de sécurité : 1024-RSA utilise

une clé 1 024 bits (moins sécurisée) et 2048-RSA une clé 2 048 bits (plus sécurisée).

d Enregistrez les informations dans un fichier de certificat en renseignant l’entrée Enregistrer sous ou en cliquant

sur le bouton Parcourir... pour localiser un dossier. (Par exemple, C:/Temp/mycert.pfx). Lorsque vous avez terminé, cliquez sur OK.

e Flash vous renvoie à la boîte de dialogue Signature numérique. Le chemin et le nom de fichier du certificat auto-

signé s’affichent dans le champ de texte Certificat. Si ce n’est pas le cas, entrez le chemin et le nom du fichier ou cliquez sur le bouton Parcourir pour le localiser et le sélectionner.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

f Entrez le mot de passe défini à l’étape b dans le champ de texte Mot de passe de la boîte de dialogue Signature

numérique. Pour plus d’informations sur la signature des applications Adobe AIR, voir « Signature numérique

d’un fichier AIR » à la page 198.

3 Pour créer le fichier de l’application et du programme d’installation, cliquez sur le bouton Publier. (Dans Flash CS4

et CS5, cliquez sur le bouton OK.) Pour créer les fichiers SWF et application.xml, vous devez tester ou déboguer l’animation avant de créer le fichier AIR.

4 Pour installer l’application, double-cliquez sur le fichier AIR (application.air) dans le dossier où vous avez

enregistré l’application.

5 Dans la boîte de dialogue Installation de l’application, cliquez sur le bouton Installer.

6 Vérifiez les paramètres d’emplacement et de préférences d’installation et assurez-vous que la case à cocher

« Démarrer l’application à la fin de l’installation » est activée. Cliquez sur Continuer.

7 Lorsque le message Installation terminée apparaît, cliquez sur Terminer.

Création d’une première application AIR for Android dans Flash Professional

Pour développer des applications AIR for Android, vous devez télécharger l’extension Flash Professional CS5 pour Android à l’adresse suivante : Adobe Labs.

Vous devez également télécharger et installer le kit SDK d’Android à partir du site Web d’Android comme indiqué dans : Android Developers : Installing the SDK (disponible en anglais uniquement).

Création d’un projet

1 Ouvrez Flash Professional CS5.

2 Créez un projet AIR for Android.

L’écran d’accueil de Flash Professional contient un lien permettant de créer une application AIR for Android. Vous pouvez également sélectionner Fichier > Nouveau, puis le modèle AIR for Android.

3 Enregistrez le document sous le nom HelloWorld.fla.

Programmation du code

Etant donné que ce didacticiel n’est pas consacré à la programmation du code, contentez-vous de programmer « Hello, World! » sur la scène à l’aide de l’outil Texte.

Définition des propriétés de l’application

1 Sélectionnez Fichier > Paramètres d’AIR for Android.

2 Sur l’onglet Général, définissez les paramètres suivants :

• Fichier de sortie : HelloWorld.apk

• Nom de l’application : HelloWorld

• ID de l’application : HelloWorld

• Version : 0.0.1

• Format : Portrait

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

3 Sur l’onglet Déploiement, définissez les paramètres suivants :

• Certificat : pointez vers un certificat de signature du code AIR valide. Vous pouvez cliquer sur le bouton Créer

pour créer un certificat. (Les applications Android déployées via Android Market doivent disposer de certificats valides jusqu’en 2033 au moins.) Entrez le mot de passe associé au certificat dans le champ Mot de passe.

• Type de déploiement Android : Déboguer

• Après la publication : sélectionnez les deux options.

• Entrez le chemin d’accès à l’outil ADB dans le sous-répertoire tools du kit SDK d’Android.

4 Cliquez sur OK pour fermer la boîte de dialogue Paramètres AIR for Android.

A ce stade de son développement, l’application ne requiert ni icônes, ni autorisations. La plupart des applications AIR for Android nécessitent certaines autorisations pour accéder aux fonctionnalités protégées. Contentez-vous de définir les autorisations réellement requises par l’application, car les utilisateurs risquent de la rejeter si elle demande un nombre trop élevé d’autorisations.

5 Enregistrez le fichier.

Mise en package et installation de l’application sur le périphérique Android

1 Veillez à activer le débogage USB sur le périphérique. Vous pouvez activer le débogage USB dans l’application

Réglages via Applications > Développement.

2 Connectez le périphérique à l’ordinateur via un câble USB.

3 Le cas échéant, installez le moteur d’exécution d’AIR. Pour ce faire, accédez à Android Market et téléchargez Adobe

AIR. (Vous pouvez également installer AIR localement à l’aide de la commande ADT « Commande ADT

installRuntime » à la page 185. Le kit SDK d’Android contient les packages Android destinés aux émulateurs et

périphériques Android.)

4 Sélectionnez Fichier > Publier.

Flash Professional crée le fichier APK, installe l’application sur le périphérique Android connecté et la lance.

Création d’une première application AIR for iOS

AIR 2.6 ou ultérieur, iOS 4.2 ou ultérieur

Vous pouvez programmer le code des fonctionnalités d’une application iOS, les créer et les tester par le biais d’outils Adobe uniquement. Toutefois, pour installer une application iOS sur un périphérique et la distribuer, vous devez appartenir au programme iOS Developer d’Apple (service payant). Une fois membre du programme iOS Developer, vous pouvez accéder au portail iOS Provisioning Portal, où vous pouvez obtenir d’Apple les éléments et fichiers suivants, dont vous devez disposer pour installer une application sur un périphérique à des fins de test et de distribution ultérieure :

• Certificats de développement et de distribution

• ID d’application

• Fichiers de configuration pour le développement et la distribution d’applications

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Création du contenu de l’application

Créez un fichier SWF qui affiche le texte « Hello world! » Vous disposez à cet effet de Flash Professional, Flash Builder ou d’un autre IDE. Cet exemple fait simplement appel à un éditeur de texte et au compilateur SWF de ligne de commande intégré au kit SDK de Flex.

1 Créez un répertoire destiné aux fichiers de l’application à un emplacement adéquat. Créez le fichier HelloWorld.as

et modifiez-le dans l’éditeur de code de votre choix.

2 Ajoutez le code suivant :

package{

import flash.display.Sprite; import flash.text.TextField; import flash.text.TextFormat; import flash.text.TextFieldAutoSize;

public class HelloWorld extends Sprite {

public function HelloWorld():void {

var textField:TextField = new TextField(); textField.text = "Hello World!"; textField.autoSize = TextFieldAutoSize.LEFT;

var format:TextFormat = new TextFormat(); format.size = 48;

textField.setTextFormat ( format ); this.addChild( textField );

}

3 Compilez la classe à l’aide du compilateur amxmlc :

amxmlc HelloWorld.as

Un fichier SWF, HelloWorld.swf, est créé dans le même dossier.

Remarque : cet exemple considère comme acquis que vous avez défini la variable d’environnement path de sorte à inclure le répertoire dans lequel réside amxmlc. Pour plus d’informations sur la définition de la variable path, voir « Variables d’environnement path » à la page 317. Vous pouvez également saisir le chemin d’accès complet à amxmlc et aux autres outils de ligne de commande utilisés dans cet exemple.

Création des icônes et des graphiques de l’écran initial de l’application

Toutes les applications iOS contiennent des icônes affichées dans l’interface utilisateur de l’application iTunes et sur l’écran du périphérique.

1 Créez un répertoire au sein du répertoire de projet et affectez-lui le nom « icons ».

2 Créez trois fichiers PNG dans le répertoire icons, Nommez-les Icon_29.png, Icon_57.png et Icon_512.png.

3 Modifiez les fichiers PNG pour créer des graphiques adaptés à l’application. Les fichiers doivent mesurer 29 pixels

sur 29 pixels, 57 pixels sur 57 pixels et 512 pixels sur 512 pixels. Dans le cadre de ce test, vous pouvez vous contenter de carrés de couleur unie.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Remarque : lorsque vous envoyez une application à l’App Store d’Apple, vous utilisez une version JPG (et non PNG) du fichier de 512 pixels. La version PNG est réservée au test des versions de développement d’une application.

Toute application iPhone affiche une image initiale lors de son chargement sur l’iPhone. Vous définissez cette image initiale dans un fichier PNG, comme suit :

1 Dans le répertoire de développement principal, créez un fichier PNG appelé Default.png. (Ne placez pas ce fichier

dans le sous-répertoire icons et respectez la casse du nom du fichier.)

2 Modifiez le fichier de sorte que ses dimensions correspondent à 320 pixels de large sur 480 pixels de haut. Pour le

moment, contentez-vous d’un contenu composé d’un rectangle blanc uni, que vous modifierez ultérieurement.

Pour plus d’informations sur ces graphiques, voir « Icônes d’une application » à la page 92.

Création du fichier descripteur de l’application

Créez un fichier descripteur de l’application qui spécifie les propriétés de base de cette dernière. Vous disposez à cet effet d’un IDE tel que Flash Builder ou un éditeur de texte.

1 Dans le dossier du projet qui contient HelloWorld.as, créez un fichier XML, HelloWorld-app.xml. Modifiez ce

fichier dans l’éditeur XML de votre choix.

2 Ajoutez le code XML suivant :

<?xml version="1.0" encoding="utf-8" ?> <application xmlns="http://ns.adobe.com/air/application/2.7" minimumPatchLevel="0">

<id>change_to_your_id</id> <name>Hello World iOS</name> <versionNumber>0.0.1</versionNumber> <filename>HelloWorld</filename> <supportedProfiles>mobileDevice</supportedProfiles> <initialWindow>

<content>HelloWorld.swf</content>

<title>Hello World!</title> </initialWindow> <icon>

<image29x29>icons/AIRApp_29.png</image29x29>

<image57x57>icons/AIRApp_57.png</image57x57>

<image512x512>icons/AIRApp_512.png</image512x512> </icon>

</application>

Par souci de simplicité, cet exemple ne définit que quelques-unes des propriétés disponibles.

Remarque : Si vous utilisez AIR 2 ou une version antérieure, vous devez utiliser l’élément

<versionNumber>.

<version> et non l’élément

3 Remplacez l’ID de l’application par l’ID spécifié dans le portail iOS Provisioning Portal. (N’incluez pas de préfixe

au début de l’ID d’application.)

4 Testez l’application avec l’application ADL :

adl HelloWorld-app.xml -screensize iPhone

L’application ADL devrait ouvrir une fenêtre sur le bureau dans laquelle figure le texte Hello World!. Si tel n’est pas le cas, vérifiez si le code source et le fichier descripteur d’application contiennent des erreurs.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Compilation du fichier IPA

Vous pouvez maintenant compiler le fichier d’installation IPA à l’aide de l’outil ADT, comme suit : Vous devez disposer de la clé privée et du certificat de développement Apple au format P12, ainsi que du profil de configuration pour le développement Apple.

Exécutez l’outil ADT en spécifiant les options suivantes (remplacez les valeurs keystore, storepass et provisioningprofile par vos propres valeurs) :

adt -package -target ipa-debug

-keystore iosPrivateKey.p12 -storetype pkcs12 -storepass qwerty12

-provisioning-profile ios.mobileprovision HelloWorld.ipa HelloWorld-app.xml HelloWorld.swf icons Default.png

(Utilisez une ligne de commande unique. Les sauts de ligne qui figurent dans cet exemple ont pour unique objet de faciliter la lecture du code.)

L’outil ADT génère le fichier d’installation de l’application iOS, HelloWorld.ipa, dans le répertoire du projet. La compilation du fichier IPA prend parfois quelques minutes.

Installation de l’application sur un périphérique

Pour installer l’application iOS à des fins de test :

1 Ouvrez l’application iTunes.

2 Le cas échéant, ajoutez à iTunes le profil de configuration associé à l’application. Dans iTunes, sélectionnez Fichier

> Ajouter le fichier à la bibliothèque. Sélectionnez ensuite le fichier du profil de configuration (dont le type de fichier correspond à mobileprovision).

Utilisez à présent le profil de configuration pour le développement afin de tester l’application sur le périphérique de développement.

Lors de la distribution ultérieure de l’application sur l’iTunes Store, vous utiliserez le profil de distribution. Pour procéder à une distribution ad hoc de l’application (en d’autres termes, pour la distribuer sur plusieurs périphériques sans passer par l’iTunes Store), utilisez le profil de configuration ad hoc.

Pour plus d’informations sur les profils de configuration, voir « Configuration d’iOS » à la page 69.

3 Certaines versions d’iTunes ne remplacent pas l’application si une version identique de l’application est déjà

installée. Dans ce cas de figure, supprimez l’application du périphérique et de la liste d’applications dans iTunes.

4 Double-cliquez sur le fichier IPA associé à l’application. Elle devrait apparaître dans la liste d’applications d’iTunes.

5 Connectez le périphérique au port USB de l’ordinateur.

6 Dans iTunes, vérifiez sur l’onglet Application associé au périphérique que l’application est sélectionnée dans la liste

d’applications à installer.

7 Sélectionnez le périphérique dans la liste de gauche d’applications. Cliquez ensuite sur le bouton Synchroniser. Une

fois la synchronisation terminée, l’application Hello World apparaît sur l’iPhone.

Si la nouvelle version n’est pas installée, supprimez-la du périphérique et de la liste d’applications dans iTunes, puis répétez la procédure. Ce cas de figure se produit parfois si la version actuellement installée utilise le même ID et le même numéro.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Modification des graphiques de l’écran initial

Avant de compiler l’application, vous avez créé le fichier Default.png (voir « Création des icônes et des graphiques de

l’écran initial de l’application » à la page 28). Ce fichier PNG contient l’image de démarrage affichée lors du

chargement de l’application. Lorsque vous avez testé l’application sur l’iPhone, peut-être avez-vous remarqué l’écran vide au démarrage.

Remplacez cette image par l’écran de démarrage de l’application (« Hello World! ») en procédant comme suit :

1 Ouvrez l’application sur le périphérique. Lorsque la première occurrence du texte « Hello World » apparaît,

appuyez sur le bouton principal (figurant sous l’écran) et maintenez-le enfoncé. Tout en maintenant appuyé le bouton principal, appuyez sur le bouton Marche/Veille figurant dans la partie supérieure de l’iPhone. Vous effectuez ainsi une capture d’écran, qui est envoyée à Pellicule.

2 Transférez l’image sur l’ordinateur de développement via iPhoto ou toute autre application adaptée. (Sous Mac OS,

vous disposez également de l’application Transfert d’images.)

Vous pouvez aussi envoyer la photo par E-mail à l’ordinateur de développement, comme suit :

• Ouvrez l’application Photos.

• Ouvrez Pellicule.

• Ouvrez la capture d’écran que vous avez effectuée.

• Touchez l’image, puis le bouton fléché figurant dans l’angle inférieur gauche. Cliquez ensuite sur le bouton

Envoyer par courrier et envoyez l’image à votre propre adresse électronique.

3 Remplacez le fichier Default.png, qui réside dans le répertoire de développement, par une version PNG de la

capture d’écran effectuée.

4 Recompilez l’application (voir « Compilation du fichier IPA » à la page 30) et installez-la à nouveau sur le

périphérique.

L’application utilise à présent le nouvel écran de démarrage au chargement.

Remarque : sous réserve de respecter les dimensions requises (320 x 480 pixels), libre à vous de créer n’importe quel graphique pour le fichier Default.png. Il est toutefois préférable que l’image issue du fichier Default.png corresponde à l’état initial de l’application.

Création d’une première application AIR de type HTML dans Dreamweaver

Pour vous familiariser rapidement avec le fonctionnement d’Adobe® AIR®, suivez les instructions ci-dessous, qui permettent de créer et de mettre en package une application AIR HTML simple, appelée « Hello World » à l’aide de l’extension Adobe® AIR® pour Dreamweaver®.

Le cas échéant, téléchargez et installez Adobe AIR, à l’adresse suivante : www.adobe.com/go/air_fr.

Pour plus d’informations sur l’installation de l’extension Adobe AIR pour Dreamweaver, voir Installation de

l’extension Adobe AIR pour Dreamweaver.

Pour une présentation de l’extension, y compris la configuration système requise, voir Extension AIR pour

Dreamweaver.

Remarque : vous ne pouvez développer des applications AIR de type HTML que pour les profils desktop et extendedDesktop. Le profil mobile n’est pas pris en charge.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Préparation des fichiers de l’application

La première page et toutes les pages connexes de l’application Adobe AIR doivent être définies dans un site Dreamweaver, comme suit :

1 Démarrez Dreamweaver et assurez-vous qu’un site est défini.

2 Pour ouvrir une nouvelle page HTML, sélectionnez Fichier > Nouveau, choisissez HTML dans la colonne Type de

page et Sans dans la colonne Mise en forme, puis cliquez sur Créer.

3 Dans la nouvelle page, tapez Hello World!

Cet exemple est extrêmement simple, mais vous avez tout loisir d’appliquer un style au texte, d’ajouter du contenu supplémentaire à la page, de lier d’autres pages à cette première page, etc.

4 Enregistrez la page (Fichier > Enregistrer) sous le nom hello_world.html. Veillez à enregistrer la page dans un site

Dreamweaver.

Pour plus d’informations sur les sites Dreamweaver, voir l’aide de Dreamweaver.

Création de l’application Adobe AIR

1 Assurez-vous que la page hello_world.html est ouverte dans la fenêtre de document Dreamweaver (voir la section

précédente pour plus d’informations sur la procédure de création de cette page).

2 Sélectionnez Site > Paramètres de l’application AIR.

La plupart des paramètres obligatoires de la boîte de dialogue Paramètres de l’application AIR et du programme d’installation sont automatiquement renseignés. Vous devez cependant sélectionner le contenu initial (première page) de votre application.

3 Cliquez sur le bouton Parcourir en regard de l’option Contenu initial, recherchez la page hello_world.html et

sélectionnez-la.

4 En regard de l’option Signature numérique, cliquez sur le bouton Définir.

Une signature numérique garantit que le code d’une application n’a pas été altéré ni endommagé depuis sa création par le développeur, et il est obligatoire d’en définir une pour toutes les applications Adobe AIR.

5 Dans la boîte de dialogue Signature numérique, sélectionnez l’option Signer le package AIR avec un certificat

numérique et cliquez sur le bouton Créer (si vous avez déjà accès à un certificat numérique, vous pouvez cliquer sur le bouton Parcourir pour le sélectionner).

6 Renseignez les champs obligatoires de la boîte de dialogue Certificat numérique auto-signé. Vous devez indiquer

votre nom, entrez et confirmez un mot de passe et attribuez un nom au fichier de certificat numérique. Dreamweaver enregistre le certificat numérique dans la racine de votre site.

7 Cliquez sur OK pour revenir à boîte de dialogue Signature numérique.

8 Dans la boîte de dialogue Signature numérique, entrez le mot de passe spécifié pour le certificat numérique et

cliquez sur OK.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

La boîte de dialogue Paramètres de l’application AIR et du programme d’installation se présente maintenant comme suit, par exemple :

Pour plus d’informations sur toutes les options de la boîte de dialogue et leur modification, voir Création d’une

application AIR dans Dreamweaver.

9 Cliquez sur le bouton Créer un fichier AIR.

Dreamweaver crée le fichier de l’application Adobe AIR et l’enregistre dans le dossier racine du site. Il crée également le fichier application.xml au même emplacement. Ce fichier sert de manifeste et définit différentes propriétés de l’application.

Installation de l’application sur un bureau

Maintenant que vous avez créé le fichier de l’application, vous pouvez l’installer sur un bureau.

1 Transférez le fichier de l’application Adobe AIR du site Dreamweaver vers votre bureau ou tout autre bureau.

Cette étape est facultative. Si vous le souhaitez, vous pouvez installer la nouvelle application sur l’ordinateur à partir du répertoire du site Dreamweaver.

2 Double-cliquez sur le fichier exécutable de l’application (fichier .air) pour installer celle-ci.

Aperçu de l’application Adobe AIR

Vous pouvez afficher un aperçu des pages constituant une application AIR à tout moment. Vous n’êtes donc pas obligé de mettre l’application en package pour voir comment elle se présentera une fois installée.

1 Le cas échéant, ouvrez la page hello_world.html dans la fenêtre de document Dreamweaver.

2 Sur la barre d’outils Document, cliquez sur le bouton Aperçu/Débogage dans le navigateur, puis sélectionnez

Aperçu dans AIR.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Vous pouvez aussi appuyer sur Ctrl+Maj+F12 (Windows) ou Cmd+Maj+F12 (Macintosh).

Lorsque vous affichez un aperçu de cette page, son apparence est identique à ce que voit l’utilisateur une fois qu’il a installé l’application sur un bureau.

Création d’une première application AIR de type HTML à l’aide du kit SDK d’AIR

Avant de commencer, vous devez installer le moteur d’exécution et configurer le kit SDK AIR. Dans ce didacticiel, vous allez utiliser l’application de débogage du lanceur AIR et l’outil AIR Developer (ADT). Les outils ADL et ADT sont des programmes de ligne de commande et résident dans le répertoire

développement SDK AIR » à la page 17). Dans ce didacticiel, il est considéré comme acquis que vous savez exécuter

des programmes à partir de la ligne de commande et configurer les variables d’environnement path requises par le système d’exploitation.

Remarque : si vous utilisez Adobe® Dreamweaver®, voir « Création d’une première application AIR de type HTML dans

Dreamweaver » à la page 31.

bin du kit SDK AIR (voir « Installation du kit de

Remarque : vous ne pouvez développer des applications AIR de type HTML que pour les profils desktop et extendedDesktop. Le profil mobile n’est pas pris en charge.

Création des fichiers du projet

Chaque projet AIR HTML doit contenir les deux fichiers suivants : un fichier descripteur d’application, qui définit les métadonnées de l’application, et une page HTML de niveau supérieur. Outre ces fichiers obligatoires, le projet comprend également un fichier de code JavaScript, classes des API AIR.

1 Créez le répertoire HelloWorld qui contiendra les fichiers du projet.

2 Créez le fichier XML HelloWorld-app.xml.

3 Créez le fichier HTML HelloWorld.html.

4 Copiez AIRAliases.js du dossier frameworks du kit SDK AIR vers le répertoire du projet.

AIRAliases.js, qui définit des variables d’alias pratiques pour les

Création du fichier descripteur d’application AIR

Pour commencer à programmer l’application AIR, créez un fichier descripteur d’application XML contenant la structure suivante :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

1 Ouvrez le fichier HelloWorld-app.xml en vue de le modifier.

2 Ajoutez l’élément <application> racine avec pour attribut l’espace de noms AIR :

<application xmlns="http://ns.adobe.com/air/application/2.7"> Le dernier segment de l’espace de noms, « 2.7 », indique la version du moteur d’exécution requis par l’application.

3 Ajoutez l’élément <id> :

<id>examples.html.HelloWorld</id> L’ID identifie l’application de manière unique, en conjonction avec l’ID d’éditeur (dérivé par AIR du certificat de signature du package d’application). L’ID d’application assure l’installation, l’accès au répertoire de stockage du système de fichiers de l’application privé, l’accès aux emplacements de stockage chiffrés privés et la communication entre les applications.

4 Ajoutez l’élément <versionNumber> :

<versionNumber>0.1</versionNumber> Permet à l’utilisateur de déterminer la version de l’application qu’il installe.

Remarque : si vous utilisez AIR 2 ou une version antérieure, vous devez utiliser l’élément

<versionNumber>.

<version> et non l’élément

5 Ajoutez l’élément <filename> :

<filename>HelloWorld</filename> Nom utilisé pour le fichier exécutable et le répertoire d’installation de l’application, ainsi que pour les autres références à cette dernière dans le système d’exploitation.

6 Ajoutez l’élément <initialWindow>, qui contient les éléments enfants suivants, afin de spécifier les propriétés de

la fenêtre initiale de l’application :

<content>HelloWorld.html</content> Identifie le fichier HTML racine que doit charger AIR.

<visible>true</visible> Indique que la fenêtre est immédiatement visible.

<width>400</width> Définit la largeur de la fenêtre (en pixels).

<height>200</height> Définit la hauteur de la fenêtre.

7 Enregistrez le fichier. Le fichier descripteur d’application terminé se présente comme suit :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

<?xml version="1.0" encoding="UTF-8"?> <application xmlns="http://ns.adobe.com/air/application/2.7"> <id>examples.html.HelloWorld</id> <versionNumber>0.1</versionNumber> <filename>HelloWorld</filename> <initialWindow> <content>HelloWorld.html</content> <visible>true</visible> <width>400</width> <height>200</height> </initialWindow> </application>

Cet exemple se contente de définir quelques-unes des propriétés d’application disponibles. Voir « Fichiers descripteurs

d’applications AIR » à la page 215 pour consulter la liste complète des propriétés de l’application, qui permettent de

définir des paramètres tels que le chrome, la taille et la transparence des fenêtres, le répertoire d’installation par défaut, les types de fichier associés et les icônes de l’application.

Création de la page HTML de l’application

Vous devez à présent créer une page HTML simple qui constituera le fichier principal de l’application AIR.

1 Ouvrez le fichier HelloWorld.html en vue de le modifier. Ajoutez le code HTML suivant :

<html> <head> <title>Hello World</title> </head> <body onLoad="appLoad()"> <h1>Hello World</h1> </body> </html>

2 Dans la section <head> du code HTML, importez le fichier AIRAliases.js :

AIR définit une propriété appelée runtime sur l’objet de fenêtre HTML. Cette propriété permet d’accéder aux classes AIR intégrées, à l’aide du nom de package complet de la classe. Pour créer un objet File AIR, par exemple, vous pourriez ajouter l’instruction suivante en JavaScript :

var textFile = new runtime.flash.filesystem.File("app:/textfile.txt");

Le fichier AIRAliases.js définit des alias pratiques pour les API AIR les plus utiles. Grâce à lui, vous pouvez par exemple raccourcir la référence à la classe File comme suit :

var textFile = new air.File("app:/textfile.txt");

3 Sous la balise script d’AIRAliases, ajoutez une autre balise script contenant une fonction JavaScript pour gérer

l’événement

onLoad :

La fonction appLoad() appelle simplement la fonction air.trace(). Lorsque vous exécutez l’application à l’aide d’ADL, le message de trace s’imprime sur la console de commande. Les instructions de trace peuvent être très utiles pour le débogage.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

4 Enregistrez le fichier.

Le fichier

<html> <head> <title>Hello World</title> <script type="text/javascript" src="AIRAliases.js"></script> <script type="text/javascript"> function appLoad(){ air.trace("Hello World"); } </script> </head> <body onLoad="appLoad()"> <h1>Hello World</h1> </body> </html>

HelloWorld.html doit maintenant se présenter comme suit :

Test de l’application

Pour exécuter et tester l’application à partir de la ligne de commande, faites appel à l’application de débogage du lanceur AIR (ADL). Le fichier exécutable ADL se trouve dans le répertoire encore installé le kit SDK AIR, voir « Installation du kit de développement SDK AIR » à la page 17.

bin du kit SDK AIR. Si vous n’avez pas

1 Ouvrez une console ou un shell de commande. Passez dans le répertoire créé pour ce projet.

2 Exécutez la commande suivante :

adl HelloWorld-app.xml

Une fenêtre AIR contenant l’application s’affiche. La fenêtre de la console présente également le message résultant de l’appel

air.trace().

Pour plus d’informations, voir « Fichiers descripteurs d’applications AIR » à la page 215.

Création du fichier d’installation AIR

Lorsque l’application s’exécute correctement, vous pouvez, à l’aide de l’outil ADT, la mettre en package sous forme de fichier d’installation AIR, c-à-d. un fichier d’archives contenant tous les fichiers de l’application, que vous pouvez distribuer à vos utilisateurs. Pour pouvoir installer un fichier AIR mis en package, vous devez installer Adobe AIR.

Pour garantir la sécurité des applications, tous les fichiers d’installation AIR doivent être signés numériquement. A des fins de développement, vous pouvez générer un certificat auto-signé de base à l’aide de l’outil ADT ou d’un autre outil de génération de certificats. Libre à vous également d’acheter un certificat de signature de code commercial auprès d’une autorité de certification telle que VeriSign ou Thawte. Lorsque les utilisateurs installent un fichier AIR autosigné, l’éditeur porte la mention « Inconnu » pendant le processus d’installation. En effet, un certificat auto-signé garantit uniquement que le fichier AIR n’a pas été modifié depuis sa création. Rien n’empêche une tierce personne de présenter un faux fichier AIR auto-signé comme étant votre application. Il est fortement recommandé de signer les fichiers AIR que vous publiez au moyen d’un certificat commercial vérifiable. Pour une présentation de la sécurité AIR, voir Sécurité AIR (développeurs ActionScript) ou Sécurité AIR (développeurs HTML).

Génération d’un certificat auto-signé et d’une paire de clés

❖ A l’invite de commande, entrez la commande suivante (le fichier exécutable ADT se trouve dans le répertoire bin

du kit SDK AIR) :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

adt -certificate -cn SelfSigned 1024-RSA sampleCert.pfx samplePassword

L’outil ADT génère le fichier de magasin de clés sampleCert.pfx, qui contient un certificat et la clé privée correspondante.

Cet exemple utilise le nombre minimal d’attributs qu’il est possible de définir pour un certificat. Le type de clé doit correspondre à 1024-RSA ou 2048-RSA (voir « Signature d’applications AIR » à la page 198).

Création du fichier d’installation AIR

❖ A l’invite de commande, entrez la commande suivante (sur une même ligne) :

adt -package -storetype pkcs12 -keystore sampleCert.pfx HelloWorld.air HelloWorld-app.xml HelloWorld.html AIRAliases.js

Vous êtes invité à entrer le mot de passe du fichier de magasin de clés.

L’argument HelloWorld.air correspond au fichier AIR généré par l’outil ADT. HelloWorld-app.xml est le fichier descripteur d’application. Les autres arguments représentent les fichiers utilisés par l’application. Cet exemple n’utilise que deux fichiers, mais vous pouvez inclure tout nombre de fichiers et de répertoires. L’outil ADT vérifie que le fichier de contenu principal, HelloWorld.html, figure dans le package, mais si vous omettez le fichier AIRAliases.js, l’application ne fonctionne pas.

Une fois le package AIR créé, vous pouvez double-cliquer dessus pour installer et exécuter l’application. Libre à vous également d’entrer le nom de fichier AIR en tant que commande dans une fenêtre de shell ou de commande.

Etapes suivantes

Dans AIR, le code HTML et JavaScript se comporte généralement comme s’il se trouvait dans un navigateur Web ordinaire. (De fait, AIR utilise le même moteur de rendu WebKit que le navigateur Web Safari.) Cependant, vous devez connaître quelques différences notoires lorsque vous développez des applications HTML dans AIR. Pour plus d’informations sur ces différences et d’autres sujets importants, voir Programming HTML and JavaScript (disponible en anglais uniquement).

Création d’une première application de bureau AIR à l’aide du kit SDK de Flex

A titre d’illustration rapide et pratique du fonctionnement d’Adobe® AIR®, suivez ces instructions pour créer une application AIR simple basée sur SWF, « Hello World », par le biais du kit SDK Flex. Ce didacticiel illustre la compilation, le test et la mise en package d’une application AIR à l’aide des outils de ligne de commande intégrés au kit SDK de Flex (ce dernier contient le kit SDK d’AIR).

Avant de commencer, vous devez installer le moteur d’exécution et configurer Adobe® Flex™. Ce didacticiel fait appel au compilateur AMXMLC, à l’application de débogage du lanceur AIR (ADL) et à l’outil AIR Developer (ADT). Ces programmes résident dans le répertoire

Création du fichier descripteur d’application AIR

Cette section est consacrée à la création du fichier descripteur d’application, à savoir un fichier XML dont la structure est la suivante :

bin du kit SDK Flex (voir « Configuration du kit SDK Flex » à la page 19).

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

1 Créez un fichier XML appelé HelloWorld-app.xml et enregistrez-le dans le répertoire du projet.

2 Ajoutez l’élément <application> avec pour attribut l’espace de noms AIR :

<application xmlns="http://ns.adobe.com/air/application/2.7"> Le dernier segment de l’espace de noms, « 2.7 », indique la version du moteur d’exécution requis par l’application.

3 Ajoutez l’élément <id> :

<id>samples.flex.HelloWorld</id> L’ID identifie l’application de manière unique, en conjonction avec l’ID d’éditeur (dérivé par AIR du certificat de signature du package d’application). Le format recommandé correspond à une chaîne de style DNS inversé dont les éléments sont séparés par un point, telle que

« com.company.AppName ». L’ID d’application assure l’installation, l’accès au répertoire de stockage du système

de fichiers de l’application privé, l’accès aux emplacements de stockage chiffrés privés et la communication entre les applications.

4 Ajoutez l’élément <versionNumber> :

<versionNumber>1.0</versionNumber> Permet à l’utilisateur de déterminer la version de l’application qu’il installe.

Remarque : si vous utilisez AIR 2 ou une version antérieure, vous devez utiliser l’élément

<versionNumber>.

<version> et non l’élément

5 Ajoutez l’élément <filename> :

<filename>HelloWorld</filename> Nom du fichier exécutable et du répertoire d’installation de l’application, ainsi que des autres références à cette dernière dans le système d’exploitation.

6 Ajoutez l’élément <initialWindow>, qui contient les éléments enfants suivants, afin de spécifier les propriétés de

la fenêtre initiale de l’application :

<content>HelloWorld.swf</content> Identifie le fichier SWF racine que doit charger AIR.

<visible>true</visible> Indique que la fenêtre est immédiatement visible.

<width>400</width> Définit la largeur de la fenêtre (en pixels).

<height>200</height> Définit la hauteur de la fenêtre.

7 Enregistrez le fichier. Le format du fichier descripteur d’application complet est le suivant :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

<?xml version="1.0" encoding="UTF-8"?> <application xmlns="http://ns.adobe.com/air/application/2.7"> <id>samples.flex.HelloWorld</id> <versionNumber>0.1</versionNumber> <filename>HelloWorld</filename> <initialWindow> <content>HelloWorld.swf</content> <visible>true</visible> <width>400</width> <height>200</height> </initialWindow> </application>

Cet exemple se contente de définir quelques-unes des propriétés d’application disponibles. Voir « Fichiers descripteurs

d’applications AIR » à la page 215 pour consulter la liste complète des propriétés de l’application, qui permettent de

définir des paramètres tels que le chrome, la taille et la transparence des fenêtres, le répertoire d’installation par défaut, les types de fichier associés et les icônes de l’application.

Programmation du code de l’application

Remarque : les applications AIR basées sur SWF peuvent utiliser une classe principale définie avec MXML ou Adobe® ActionScript® 3.0. Cet exemple définit sa classe principale par le biais d’un fichier MXML. Le processus de création d’une application AIR avec une classe ActionScript principale est similaire. Au lieu de compiler un fichier MXML pour obtenir le fichier SWF, vous compilez le fichier de classe ActionScript. Si vous utilisez ActionScript, la classe principale doit étendre flash.display.Sprite.

A l’instar de toutes les applications Flex, les applications AIR basées sur la structure Flex contiennent un fichier MXML principal. Les applications de bureau AIR font appel au composant WindowedApplication en tant qu’élément racine au lieu du composant Application. Le composant WindowedApplication fournit les propriétés, les méthodes et les événements de contrôle de l’application et de sa fenêtre initiale. Pour les plates-formes et profils pour lesquels AIR ne prend pas en charge les fenêtres multiples, continuez à utiliser le composant Application. Dans les applications mobiles Flex, vous disposez également des composants View ou TabbedViewNavigatorApplication.

La procédure suivante permet de créer l’application Hello World :

1 Créez un fichier appelé HelloWorld.mxml dans un éditeur de texte et ajoutez le code MXML suivant :

<?xml version="1.0" encoding="utf-8"?> <s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"

xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" title="Hello World">

</s:WindowedApplication>

2 Ajoutez ensuite un composant Label à l’application (placez-le dans la balise WindowedApplication).

3 Définissez la propriété text du composant Label sur « Hello AIR ».

4 Définissez les contraintes de mise en forme de sorte qu’il reste centré.

L’exemple suivant illustre le code dans son état actuel :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

<?xml version="1.0" encoding="utf-8"?> <s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"

xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" title="Hello World">

<s:Label text="Hello AIR" horizontalCenter="0" verticalCenter="0"/>

</s:WindowedApplication>

Compilation de l’application

Avant d’exécuter et de déboguer l’application, compilez le code MXML dans un fichier SWF par le biais du compilateur amxmlc. Le compilateur amxmlc réside dans le répertoire pouvez définir la variable d’environnement path de l’ordinateur de sorte à inclure le répertoire bin du kit SDK Flex. Définir cette variable d’environnement simplifie l’exécution des utilitaires de ligne de commande.

1 Ouvrez une interface de commande ou un terminal et accédez au dossier de projet de l’application AIR.

2 Entrez la commande suivante :

amxmlc HelloWorld.mxml

L’exécution de amxmlc produit HelloWorld.swf, qui contient le code compilé de l’application.

bin du kit SDK Flex. Le cas échéant, vous

Remarque : s’il est impossible de compiler l’application, corrigez les fautes d’orthographe ou les erreurs de syntaxe. Les erreurs et les avertissements sont affichés dans la fenêtre de console d’exécution du compilateur amxmlc.

Pour plus d’informations, voir « Compilation de fichiers sources MXML et ActionScript pour AIR » à la page 163.

Test de l’application

Pour exécuter et tester l’application à partir de la ligne de commande, faites appel à l’application de débogage du lanceur AIR (ADL) afin de lancer l’application par le biais du fichier descripteur correspondant. (L’application ADL réside dans le répertoire bin du kit SDK Flex.)

❖ A l’invite de commande, entrez la commande suivante :

adl HelloWorld-app.xml

L’application AIR résultante ressemble à l’illustration suivante :

Grâce aux propriétés horizontalCenter et verticalCenter du contrôle Label, le texte est placé au centre de la fenêtre. Vous pouvez déplacer ou redimensionner la fenêtre comme pour toute autre application de bureau.

Pour plus d’informations, voir « Application de débogage du lanceur AIR (ADL) » à la page 167.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Création du fichier d’installation AIR

Pour garantir la sécurité des applications, tous les fichiers d’installation AIR doivent être signés numériquement. A des fins de développement, vous pouvez générer un certificat auto-signé de base à l’aide de l’outil ADT ou d’un autre outil de génération de certificats. Vous pouvez également acheter un certificat développeur auprès d’une autorité de certification commerciale. Lorsque les utilisateurs installent un fichier AIR auto-signé, l’éditeur porte la mention « Inconnu » pendant le processus d’installation. En effet, un certificat auto-signé garantit uniquement que le fichier AIR n’a pas été modifié depuis sa création. Rien n’empêche une tierce personne de présenter un faux fichier AIR autosigné comme étant votre application. Il est fortement recommandé de signer les fichiers AIR que vous publiez au moyen d’un certificat commercial vérifiable. Pour une présentation de la sécurité AIR, voir Sécurité AIR (développeurs ActionScript) ou Sécurité AIR (développeurs HTML).

Génération d’un certificat auto-signé et d’une paire de clés

❖ A l’invite de commande, entrez la commande suivante (le fichier exécutable ADT réside dans le répertoire bin du

kit SDK Flex) :

adt -certificate -cn SelfSigned 1024-RSA sampleCert.pfx samplePassword

Création d’un package AIR

❖ A l’invite de commande, entrez la commande suivante (sur une même ligne) :

adt -package -storetype pkcs12 -keystore sampleCert.pfx HelloWorld.air HelloWorld-app.xml HelloWorld.swf

Vous êtes invité à entrer le mot de passe du fichier de magasin de clés. Tapez le mot de passe et appuyez sur Entrée. Les caractères saisis ne sont pas affichés par mesure de sécurité.

Pour plus d’informations, voir « Mise en package d’un fichier d’installation AIR de bureau » à la page 55.

Création d’une première application AIR for Android à l’aide du kit SDK de Flex

Installez et configurez au préalable les kits SDK d’AIR et de Flex. Ce didacticiel fait appel au compilateur AMXMLC du kit SDK de Flex, ainsi qu’à l’application de débogage du lanceur AIR (ADL) et à l’outil AIR Developer (ADT) du kit SDK d’AIR. Voir « Configuration du kit SDK Flex » à la page 19.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Remarque : pour plus d’informations sur le développement d’applications iPhone, voir Création d’une application

iPhone Hello World dans Flash Professional CS5.

Création du fichier descripteur d’application AIR

Cette section est consacrée à la création du fichier descripteur d’application, à savoir un fichier XML dont la structure est la suivante :

</application>

1 Créez un fichier XML appelé HelloWorld-app.xml et enregistrez-le dans le répertoire du projet.

2 Ajoutez l’élément <application> avec pour attribut l’espace de noms AIR :

<application xmlns="http://ns.adobe.com/air/application/2.7"> Le dernier segment de l’espace de noms, « 2.7 », indique la version du moteur d’exécution requis par l’application.

3 Ajoutez l’élément <id> :

<id>samples.android.HelloWorld</id> L’ID identifie l’application de manière unique, en conjonction avec l’ID d’éditeur (extrait par AIR du certificat de signature du package d’application). Le format recommandé est une chaîne de type DNS inversé, dont les valeurs sont séparées par un point, telle que

4 Ajoutez l’élément <versionNumber> :

« com.société.NomApp ».

<versionNumber>0.0.1</versionNumber> Permet à l’utilisateur de déterminer la version de l’application qu’il installe.

5 Ajoutez l’élément <filename> :

6 Ajoutez l’élément <initialWindow>, qui contient les éléments enfants suivants, afin de spécifier les propriétés de

la fenêtre initiale de l’application :

<content>HelloWorld.swf</content> Identifie le fichier HTML racine que doit charger AIR.

7 Ajoutez l’élément <supportedProfiles>.

<supportedProfiles>mobileDevice</supportedProfiles> Indique que l’application s’exécute dans le profil mobile uniquement.

8 Enregistrez le fichier. Le format du fichier descripteur d’application complet est le suivant :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

<?xml version="1.0" encoding="UTF-8"?> <application xmlns="http://ns.adobe.com/air/application/2.7"> <id>samples.android.HelloWorld</id> <versionNumber>0.0.1</versionNumber> <filename>HelloWorld</filename> <initialWindow> <content>HelloWorld.swf</content> </initialWindow>

<supportedProfiles>mobileDevice</supportedProfiles>

</application>

Cet exemple se contente de définir quelques-unes des propriétés d’application disponibles. Vous disposez d’autres paramètres dans le fichier descripteur de l’application. Vous pouvez, par exemple, ajouter <fullScreen>true</fullScreen> à l’élément initialWindow pour créer une application en plein écran. Pour activer le débogage à distance et les fonctionnalités à accès contrôlé sous Android, vous devez également ajouter des autorisations Android sur le fichier descripteur de l’application. Etant donné que cette application simple ne requiert aucune autorisation, il est inutile d’en ajouter maintenant.

Pour plus d’informations, voir « Définition des propriétés d’une application mobile » à la page 74.

Programmation du code de l’application

Créez le fichier HelloWorld.as et ajoutez le code suivant à l’aide d’un éditeur de texte :

package {

import flash.display.Sprite; import flash.text.TextField;

public class HelloWorld extends Sprite {

public function HelloWorld() {

var textField:TextField = new TextField(); textField.text = "Hello, World!"; stage.addChild( textField );

}

Compilation de l’application

1 Ouvrez une interface de commande ou un terminal et accédez au dossier de projet de l’application AIR.

2 Entrez la commande suivante :

amxmlc HelloWorld.as

bin du kit SDK Flex. Le cas échéant, vous

L’exécution de amxmlc produit HelloWorld.swf, qui contient le code compilé de l’application.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

Pour plus d’informations, voir « Compilation de fichiers sources MXML et ActionScript pour AIR » à la page 163.

Test de l’application

❖ A l’invite de commande, entrez la commande suivante :

adl HelloWorld-app.xml

Pour plus d’informations, voir « Simulation de périphérique à l’aide de l’application ADL » à la page 104.

Création du fichier de package APK

Lorsque l’application s’exécute correctement, vous pouvez la mettre en package sous forme de fichier APK à l’aide de l’outil ADT. Un fichier de package APK correspond au format de fichier d’application Android natif, que vous pouvez distribuer aux utilisateurs.

Toutes les applications Android doivent être signées. A l’encontre des fichiers AIR, une application Android est généralement signée à l’aide d’un certificat auto-signé. Le système d’exploitation Android ne tente pas d’identifier le développeur de l’application. Vous pouvez signer un package Android à l’aide d’un certificat généré par l’outil ADT. Les certificats associés aux applications destinées au marché Android doivent être valides pendant 25 ans au moins.

Génération d’un certificat auto-signé et d’une paire de clés

❖ A l’invite de commande, entrez la commande suivante (le fichier exécutable ADT réside dans le répertoire bin du

kit SDK Flex) :

adt -certificate -validityPeriod 25 -cn SelfSigned 1024-RSA sampleCert.pfx samplePassword

Cet exemple utilise le nombre minimal d’attributs qu’il est possible de définir pour un certificat. Le type de clé doit être soit 1024-RSA, soit 2048-RSA (voir « Commande ADT certificate » à la page 182).

Création d’un package AIR

❖ A l’invite de commande, entrez la commande suivante (sur une même ligne) :

adt -package -target apk -storetype pkcs12 -keystore sampleCert.p12 HelloWorld.apk HelloWorld-app.xml HelloWorld.swf

Vous êtes invité à entrer le mot de passe du fichier de magasin de clés. Saisissez le mot de passe et appuyez sur Entrée.

Pour plus d’informations, voir « Mise en package d’une application AIR mobile » à la page 97.

Installation du moteur d’exécution d’AIR

Vous pouvez installer la version la plus récente du moteur d’exécution d’AIR sur le périphérique à partir d’Android Market. Vous pouvez également installer le moteur d’exécution intégré au kit SDK sur un périphérique ou un émulateur Android.

❖ A l’invite de commande, entrez la commande suivante (sur une même ligne) :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Création d’une première application AIR

adt -installRuntime -platform android -platformsdk

Définissez l’indicateur -platformsdk sur le répertoire qui stocke le kit SDK d’Android (indiquez le parent du dossier tools).

L’outil ADT installe le fichier Runtime.apk intégré au kit SDK.

Pour plus d’informations, voir « Installation du moteur d’exécution et des applications AIR à des fins de

développement » à la page 112.

Installation de l’application AIR

❖ A l’invite de commande, entrez la commande suivante (sur une même ligne) :

adt -installApp -platform android -platformsdk path-to-android-sdk -package path-to-app

Définissez l’indicateur -platformsdk sur le répertoire qui stocke le kit SDK d’Android (indiquez le parent du dossier tools).

Pour plus d’informations, voir « Installation du moteur d’exécution et des applications AIR à des fins de

développement » à la page 112.

Vous pouvez lancer l’application en touchant l’icône correspondante sur l’écran du périphérique ou de l’émulateur.

Dernière mise à jour le 14/11/2013

Chapitre 6 : Développement d’applications de bureau AIR

Flux de travail de développement d’une application de bureau AIR

Le flux de travail de base de développement d’une application AIR s’apparente à la plupart des modèles de développement : code, compilation, test, puis, en fin de cycle, mise en package dans un fichier de programme d’installation.

Vous pouvez programmer le code de l’application en Flash, Flex, ou ActionScript et le compiler dans Flash Professional, Flash Builder ou les compilateurs de ligne de commande mxmlc et compc. Vous pouvez également programmer le code de l’application en HTML et JavaScript et sauter l’étape de compilation.

Vous pouvez tester des applications de bureau AIR par le biais de l’application ADL, qui exécute une application sans mise en package et installation préalables. Flash Professional, Flash Builder, Dreamweaver et l’IDE Aptana s’intègrent tous au débogueur Flash. Vous pouvez également lancer manuellement l’outil de débogage, FDB, lorsque vous utilisez l’application ADL à partir de la ligne de commande. L’application ADL affiche quant à elle des messages d’erreur et des instructions trace.

Toute application AIR doit être mise en package dans un fichier d’installation. Le format du fichier AIR multiplateformes est recommandé, sauf dans les cas suivants :

• Vous devez accéder à des API qui dépendent de la plate-forme, telles que la classe NativeProcess.

• Votre application fait appel à des extensions natives.

Dans ce cas de figure, vous pouvez mettre en package une application AIR en tant que fichier de programme d’installation natif propre à une plate-forme donnée.

Applications de type SWF

1 Programmez le code MXML ou ActionScript.

2 Créez les actifs requis, tels que les fichiers de bitmap d’icône.

3 Créez le fichier descripteur de l’application.

4 Compilez le code ActionScript.

5 Testez l’application.

6 Mettez en package l’application et signez-la en tant que fichier AIR à l’aide de la cible air.

Applications de type HTML

1 Programmez le code HTML et JavaScript.

2 Créez les actifs requis, tels que les fichiers de bitmap d’icône.

3 Créez le fichier descripteur de l’application.

4 Testez l’application.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

5 Mettez en package l’application et signez-la en tant que fichier AIR à l’aide de la cible air.

Création de programmes d’installation natifs destinés aux applications AIR

1 Programmez le code (ActionScript ou HTML et JavaScript).

2 Créez les actifs requis, tels que les fichiers de bitmap d’icône.

3 Créez le descripteur de l’application en spécifiant le profil extendedDesktop.

4 Compilez tout code ActionScript.

5 Testez l’application.

6 Mettez en package l’application sur chaque plate-forme cible à l’aide de la cible native.

Remarque : le programme d’installation natif correspondant à une plate-forme cible doit être créé sur cette plate-forme. Vous ne pouvez pas, par exemple, créer un programme d’installation Windows sur un ordinateur Mac. Vous pouvez utiliser une machine virtuelle, telle que VMWare, pour exécuter plusieurs plates-formes sur le même ordinateur.

Création d’applications AIR à l’aide d’un paquet de moteur d’exécution captif

1 Programmez le code (ActionScript ou HTML et JavaScript).

2 Créez les actifs requis, tels que les fichiers de bitmap d’icône.

3 Créez le descripteur de l’application en spécifiant le profil extendedDesktop.

4 Compilez tout code ActionScript.

5 Testez l’application.

6 Mettez en package l’application sur chaque plate-forme cible à l’aide de la cible bundle.

7 Créez un programme d’installation à l’aide des fichiers du paquet. (Le kit SDK d’AIR ne fournit aucun outil pour

créer un tel programme d’installation, mais de nombreux kits d’outils tiers sont disponibles.)

Remarque : le paquet correspondant à une plate-forme cible doit être créé sur cette plate-forme. Vous ne pouvez pas, par exemple, créer un paquet Windows sur un ordinateur Mac. Vous pouvez utiliser une machine virtuelle, telle que VMWare, pour exécuter plusieurs plates-formes sur le même ordinateur.

Définition des propriétés d’une application de bureau

Définissez les propriétés de base de l’application dans le fichier descripteur correspondant. Cette section est consacrée aux propriétés des applications de bureau AIR. Les éléments du fichier descripteur d’application font l’objet d’une description détaillée dans « Fichiers descripteurs d’applications AIR » à la page 215.

Version du moteur d’exécution d’AIR requise

Indiquez la version du moteur d’exécution d’AIR requise par l’application à l’aide de l’espace de noms du fichier descripteur de l’application.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Assigné dans l’élément application, l’espace de noms détermine globalement les fonctionnalités dont dispose l’application. Ainsi, si l’application utilise l’espace de noms d’AIR 1.5 et qu’AIR 3.0 est installé sur l’ordinateur ou le périphérique de l’utilisateur, elle assimile le comportement d’AIR à celui de la version 1.5, même s’il a été modifié dans AIR 3.0. Pour que l’application accède au nouveau comportement et aux nouvelles fonctionnalités, vous devez au préalable modifier l’espace de noms et publier une mise à jour. Les modifications associées à la sécurité et à WebKit constituent les principales exceptions à la règle.

Spécifiez l’espace de noms à l’aide de l’attribut xmlns de l’élément racine

application :

Voir aussi

« application » à la page 220

Identité d’une application

Plusieurs paramètres devraient être propres à chaque application publiée, à savoir l’ID, le nom et le nom de fichier.

<id>com.example.MyApplication</id> <name>My Application</name> <filename>MyApplication</filename>

Voir aussi

« id » à la page 235

« filename » à la page 231

« name » à la page 243

Version d’une application

Dans les versions d’AIR antérieures à 2.5, spécifiez l’application dans l’élément version. Vous pouvez utiliser n’importe quelle chaîne. Le moteur d’exécution d’AIR n’interprète pas la chaîne. En d’autres termes, « 2.0 » n’est pas considéré comme une version ultérieure à « 1.0 ».

<version>1.23 Beta 7</version>

Dans AIR 2.5 et ultérieur, spécifiez la version de l’application dans l’élément versionNumber. L’élément version est à présent obsolète. Si vous définissez une valeur dans

versionNumber, vous devez utiliser une séquence de trois

nombres au plus, séparés par un point (« 0.1.2 », par exemple). Chaque segment du numéro de la version se compose de trois chiffres au plus. (En d’autres termes, la version la plus longue autorisée correspond à « 999.999.999 ».) Vous ne devez pas obligatoirement inclure trois segments dans le nombre. Les numéros de version « 1 » et « 1.0 » sont également valides.

Vous pouvez aussi définir le libellé de la version à l’aide de l’élément

versionLabel. Si vous ajoutez un libellé de

version, il remplace le numéro de version dans les boîtes de dialogue du programme d’installation de l’application AIR, par exemple.

<versionNumber>1.23.7<versionNumber> <versionLabel>1.23 Beta 7</versionLabel>

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Voir aussi

« version » à la page 251

« versionLabel » à la page 251

« versionNumber » à la page 252

Propriétés de la fenêtre principale

Lorsqu’AIR démarre une application à partir du bureau, il crée une fenêtre et charge dans celle-ci la page HTML ou le fichier SWF principal. AIR fait appel aux éléments enfants de l’élément comportement initiaux de la fenêtre initiale de l’application.

• content : fichier SWF principal de l’application dans l’élément enfant content de l’élément initalWindow. Si vous

ciblez des périphériques dans le profil de bureau, vous pouvez utiliser un fichier SWF ou HTML.

<content>MyApplication.swf</content>

</initialWindow>

Vous devez inclure ce fichier dans le package AIR (à l’aide de l’outil ADT ou de l’IDE). Se contenter de faire référence au nom dans le descripteur d’application n’entraîne pas l’inclusion automatique du fichier dans le package.

initialWindow pour contrôler l’aspect et le

• depthAndStencil : indique s’il est nécessaire d’utiliser le tampon de profondeur ou le tampon de modèle. Ces

tampons s’utilisent normalement avec du contenu 3D.

• height : hauteur de la fenêtre initiale.

• maximizable : indique si le chrome système d’agrandissement de la fenêtre est affiché.

• maxSize : taille maximale autorisée.

• minimizable : indique si le chrome système de réduction de la fenêtre en icône est affiché.

• minSize : taille minimale autorisée.

• renderMode : dans AIR 3 ou les versions ultérieures, le mode de rendu peut être défini sur auto, cpu, direct ou gpu

pour les applications de bureau. Dans les versions antérieures d’AIR, ce paramètre est ignoré sur les plates-formes de bureau. Il est impossible de modifier le paramètre renderMode au moment de l’exécution.

• auto : pratiquement identique au mode cpu.

• cpu : les objets d’affichage sont rendus et copiés pour afficher la mémoire dans le logiciel. StageVideo est

disponible uniquement lorsqu’une fenêtre est en mode plein écran. Stage3D fait appel au moteur de rendu du logiciel.

• direct : les objets d’affichage sont rendus par le logiciel du moteur d’exécution, mais la copie de l’image rendue

pour afficher la mémoire (blitting) est effectuée par accélération matérielle. StageVideo est disponible. Stage3D fait appel à l’accélération matérielle, lorsque cela est possible. Si la transparence de la fenêtre est définie sur true, la fenêtre revient au rendu logiciel et au blitting.

Remarque : pour tirer profit de l’accélération par processeur graphique du contenu Flash sur les plates-formes AIR mobiles, Adobe recommande d’utiliser renderMode="direct" (c’est-à-dire, Stage3D) plutôt que renderMode="gpu". Adobe prend officiellement en charge les structures d’application basées sur Stage3D suivantes et recommande leur utilisation : Starling (2D) et Away3D (3D). Pour plus d’informations sur Stage3D et Starling/Away3D, voir http://gaming.adobe.com/getstarted/.

• gpu : l’accélération matérielle est utilisée, le cas échéant.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

• requestedDisplayResolution : indique si l’application doit utiliser le mode de résolution standard ou high (élevé)

sur les ordinateurs MacBook Pro dotés d’écrans haute résolution. Sur toutes les autres plates-formes, cette valeur est ignorée. Si sa valeur est standard, chaque pixel de la scène est rendu par quatre pixels à l’écran. Si la valeur est high, chaque pixel correspond à un seul pixel physique à l’écran. La valeur spécifiée est utilisée pour toutes les fenêtres d’application. L’utilisation de l’élément AIR (en tant qu’enfant de l’élément

intialWindow) est disponible dans AIR 3.6 et ultérieur.

requestedDisplayResolution pour les applications de bureau

• resizable : indique si le chrome système de redimensionnement de la fenêtre est affiché.

• systemChrome : indique si les caractéristiques standard du système d’exploitation sont utilisées. Il est impossible

de modifier le paramètre systemChrome d’une fenêtre à l’exécution.

• title : titre de la fenêtre.

• transparent : indique si la fenêtre est semi-transparente par rapport à l’arrière-plan. Si la transparence est activée,

la fenêtre ne peut pas utiliser le chrome système. Il est impossible de modifier le paramètre transparent d’une fenêtre à l’exécution.

• visible : indique si la fenêtre est visible dès sa création. La fenêtre est initialement invisible par défaut, afin que

l’application puisse dessiner son contenu avant d’activer elle-même sa visibilité.

• width : largeur de la fenêtre.

• x : position horizontale de la fenêtre.

• y : position verticale de la fenêtre.

Voir aussi

« content » à la page 225

« depthAndStencil » à la page 227

« height » à la page 234

« maximizable » à la page 241

« maxSize » à la page 242

« minimizable » à la page 242

« minSize » à la page 242

« renderMode » à la page 245

« requestedDisplayResolution » à la page 246

« resizable » à la page 247

« systemChrome » à la page 249

« title » à la page 250

« transparent » à la page 251

« visible » à la page 252

« width » à la page 253

« x » à la page 253

« y » à la page 253

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Fonctionnalités associées au bureau

Les éléments suivants contrôlent les fonctionnalités d’installation sur le bureau et de mise à jour.

• customUpdateUI : permet d’utiliser vos propres boîtes de dialogue lors de la mise à jour d’une application. Si cet

élément est défini sur

• fileTypes : indique les types de fichiers ouverts par défaut dans l’application. Si une autre application est déjà

associée par défaut à un type de fichier, AIR ne remplace pas l’enregistrement existant. L’application peut toutefois remplacer l’enregistrement à l’exécution par le biais de la méthode NativeApplication. Il est recommandé de demander à l’utilisateur s’il autorise le remplacement d’associations de types de fichiers existantes.

Remarque : l’enregistrement du type de fichier est ignoré lors de la mise en package d’une application en tant que paquet de moteur d’exécution captif (à l’aide de la cible devez créer un programme d’installation qui effectue lui-même l’enregistrement.

• installFolder : indique un chemin relatif au dossier d’installation standard de l’application. Ce paramètre permet de

définir un nom de dossier personnalisé, ainsi que de grouper plusieurs applications dans un dossier commun.

• programMenuFolder : indique l’arborescence de menus associée au menu Tous les programmes de Windows. Ce

paramètre permet de grouper plusieurs applications au sein d’un menu commun. Si vous ne spécifiez pas de dossier de menus, le raccourci associé à l’application est directement ajouté au menu principal.

false (valeur par défaut), les boîtes de dialogue AIR standard sont utilisées.

setAsDefaultApplication() de l’objet

-bundle). Pour enregistrer un type de fichier donné, vous

Voir aussi

« customUpdateUI » à la page 226

« fileTypes » à la page 232

« installFolder » à la page 238

« programMenuFolder » à la page 244

Profils pris en charge

Si l’application ne peut s’exécuter que sur le bureau, vous pouvez interdire son installation sur des périphériques issus d’un autre profil en excluant celui-ci de la liste des profils pris en charge. Si l’application utilise la classe NativeProcess ou des extensions natives, vous devez prendre en charge le profil

Si l’élément l’application prend en charge tous les profils définis. Pour restreindre l’application à une liste déterminée de profils, recensez ces derniers en séparant chaque profil par un espace blanc :

<supportedProfiles>desktop extendedDesktop</supportedProfiles>

Pour consulter la liste des classes ActionScript prises en charge par les profils desktop et extendedDesktop, voir « Fonctionnalités des différents profils » à la page 256.

supportedProfile ne figure pas dans le descripteur d’application, il est considéré comme acquis que

Voir aussi

« supportedProfiles » à la page 248

extendedDesktop.

Extensions natives requises

Les applications qui prennent en charge le profil extendedDesktop peuvent recourir aux extensions natives.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Déclarez toutes les extensions natives auxquelles fait appel l’application AIR dans le descripteur de l’application. L’exemple suivant illustre la syntaxe permettant de spécifier deux extensions natives requises :

<extensions> <extensionID> com.example.extendedFeature</extensionID>

<extensionID> com.example.anotherFeature</extensionID>

</extensions>

La valeur de l’élément extensionID est identique à celle de l’élément id dans le fichier descripteur de l’extension. Le fichier descripteur de l’extension est un fichier XML appelé extension.xml. Il est mis en package dans le fichier ANE fourni par le développeur de l’extension native.

Icônes d’une application

Les icônes spécifiées dans le descripteur d’application sont associées sur le bureau au fichier d’application, au raccourci et au menu du programme. L’icône de l’application doit être fournie sous la forme d’un ensemble d’images PNG de 16x16, 32x32, 48x48 et 128x128 pixels. Spécifiez le chemin d’accès aux fichiers d’icône dans l’élément icon du fichier descripteur de l’application :

<icon>

<image16x16>assets/icon16.png</image16x16> <image32x32>assets/icon32.png</image32x32> <image48x48>assets/icon48.png</image48x48> <image128x128>assets/icon128.png</image128x128>

</icon>

Si vous ne fournissez pas d’icône de la taille indiquée, la taille suivante est utilisée et l’image est mise à l’échelle en conséquence. Si vous ne fournissez pas d’icône, une icône système par défaut est utilisée.

Voir aussi

« icon » à la page 234

« imageNxN » à la page 235

Paramètres ignorés

Les applications installées sur le bureau ignorent les paramètres d’application qui s’appliquent aux fonctionnalités d’un profil mobile. Les paramètres ignorés sont les suivants :

• android

• aspectRatio

• autoOrients

• fullScreen

• iPhone

• renderMode (versions antérieures à AIR 3)

• requestedDisplayResolution

• softKeyboardBehavior

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Débogage d’une application de bureau AIR

Si vous développez une application par le biais d’un IDE tel que Flash Builder, Flash Professional ou Dreamweaver, les outils de débogage sont généralement intégrés. Pour déboguer une application, il suffit de la lancer en mode de débogage. Si vous n’utilisez pas d’IDE qui prend en charge le débogage direct, vous disposez de l’application de débogage du lanceur AIR (ADL) et du programme Flash Debugger (FDB) pour déboguer l’application.

Voir aussi

De Monsters: Monster Debugger (disponible en anglais uniquement)

« Débogage à l’aide de l’outil AIR HTML Introspector » à la page 294

Exécution d’une application à l’aide de l’application ADL

L’utilisation d’ADL permet d’exécuter une application AIR sans la mettre en package et l’installer. Transmettez le fichier descripteur de l’application à l’application ADL sous forme de paramètre, comme illustré par l’exemple suivant (compilez au préalable le code ActionScript de l’application) :

adl myApplication-app.xml

ADL imprime les instructions trace, les exceptions d’exécution et les erreurs d’analyse HTML dans la fenêtre du terminal. Si un processus FDB attend une connexion entrante, l’application ADL se connecte au débogueur.

Vous pouvez également utiliser ADL pour déboguer une application AIR faisant appel à des extensions natives. Exemple :

adl -extdir extensionDirs myApplication-app.xml

Voir aussi

« Application de débogage du lanceur AIR (ADL) » à la page 167

Impression d’instructions trace

Pour imprimer des instructions trace sur la console utilisée pour exécuter ADL, ajoutez des instructions trace au code à l’aide de la fonction

Remarque : si vos instructions

ErrorReportingEnable ou TraceOutputFileEnable dans le fichier mm.cfg. Pour plus d’informations sur

l’emplacement propre à la plate-forme de ce fichier, voir Modification du fichier mm.cfg.

Exemple ActionScript :

//ActionScript trace("debug message");

Exemple JavaScript :

//JavaScript air.trace("debug message");

Dans le code JavaScript, vous pouvez utiliser les fonctions alert() et confirm() afin d’afficher les messages de débogage provenant de l’application. En outre, les numéros de ligne correspondant aux erreurs de syntaxe, de même que toutes les exceptions JavaScript non interceptées sont imprimées sur la console.

trace() :

trace() ne s’affichent pas sur la console, assurez-vous de ne pas avoir spécifié

Remarque : pour pouvoir utiliser le préfixe air illustré dans l’exemple JavaScript, vous devez importer le fichier AIRAliases.js dans la page. Ce fichier réside dans le répertoire frameworks du kit SDK d’AIR.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Connexion au programme Flash Debugger (FDB)

Pour déboguer une application AIR à l’aide de Flash Debugger, ouvrez une session FDB, puis lancez l’application à l’aide d’ADL.

Remarque : dans les applications AIR de type SWF, il est nécessaire de compiler les fichiers sources ActionScript à l’aide de l’indicateur Paramètres de publication.)

1 Lancez le programme FDB. Le programme FDB est disponible dans le répertoire bin du kit SDK Flex.

La console affiche l’invite de FDB :

2 Exécutez la commande run : <fdb>run [Entrée].

3 Dans une console de shell ou de commande différente, lancez une version de débogage de l’application :

adl myApp.xml

4 A l’aide des commandes de FDB, définissez les points d’arrêt souhaités.

5 Saisissez : continue [Entrée]

Si l’application AIR est de type SWF, le débogueur ne contrôle que l’exécution du code ActionScript. Si l’application AIR est de type HTML, le débogueur ne contrôle que l’exécution du code JavaScript.

-debug. (Dans Flash Professional, cochez l’option Autoriser le débogage dans la boîte de dialogue

<fdb>

Pour exécuter ADL sans vous connecter au débogueur, ajoutez l’option

adl myApp.xml -nodebug

Pour obtenir des informations de base sur les commandes FDB, exécutez la commande help :

<fdb>help [Enter]

Pour plus d’informations sur les commandes FDB, voir Utilisation des commandes du débogueur de ligne de

commande dans la documentation Flex.

-nodebug :

Mise en package d’un fichier d’installation AIR de bureau

Chaque application AIR doit disposer d’au moins un fichier descripteur d’application et d’un fichier SWF ou HTML principal. Il est également impératif de mettre en package dans le fichier AIR tout autre actif à installer avec l’application.

Cet article est consacré à la mise en package d’une application AIR à l’aide des outils de ligne de commande intégrés au kit SDK. Pour plus d’informations sur la mise en package d’une application par le biais de l’un des outils de création d’Adobe, voir :

• Adobe® Flex® Builder™, voir Packaging AIR applications with Flex Builder (disponible en anglais uniquement)

• Adobe® Flash® Builder™, voir Création de packages d’application AIR avec Flash Builder

• Adobe® Flash® Professional, voir Publication pour Adobe AIR

• Adobe® Dreamweaver®, voir Création d’une application AIR dans Dreamweaver

Tous les fichiers du programme d’installation AIR doivent être signés à l’aide d’un certificat numérique. Le programme d’installation AIR fait appel à la signature pour vérifier que le fichier de l’application n’a pas été modifié depuis que vous y avez apposé votre signature. Vous pouvez utiliser un certificat de signature de code provenant d’une autorité de certification ou un certificat auto-signé.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Un certificat émis par une autorité de certification approuvée offre aux utilisateurs de l’application une certaine garantie de votre identité en tant qu’éditeur. La boîte de dialogue d’installation reflète le fait que votre identité est vérifiée par une autorité de certification :

Boîte de dialogue de confirmation de l’installation d’une application signée par un certificat approuvé

Lorsque vous utilisez un certificat auto-signé, les utilisateurs n’ont aucun moyen de vérifier que vous êtes véritablement le signataire. Par ailleurs, un tel certificat ne garantit en aucune façon que le package n’a pas été modifié (il se peut en effet qu’un faux soit substitué au fichier d’installation légitime avant que l’utilisateur ne l’ait en sa possession). La boîte de dialogue d’installation reflète le fait que l’identité de l’éditeur ne peut être avérée. Les risques sécuritaires liés à l’installation de l’application sont donc plus importants :

Boîte de dialogue de confirmation de l’installation d’une application signée par un certificat auto-signé

Vous pouvez créer et signer un package de fichier AIR au cours de la même opération grâce à la commande -package d’ADT. Vous avez également la possibilité de créer un package non signé intermédiaire à l’aide de la commande

prepare. Vous pouvez ensuite signer ce package intermédiaire au cours d’une étape distincte en utilisant la

commande

-sign.

Remarque : la version 1.5 et les versions ultérieures de Java ne prennent pas en charge les caractères ASCII étendus dans les mots de passe de protection des fichiers de certificats PKCS12. Lorsque vous créez ou exportez le fichier de certificat de signature du code, utilisez uniquement des caractères ASCII ordinaires dans le mot de passe.

Lors de la signature du package d’installation, l’outil ADT contacte automatiquement un serveur d’autorité d’horodatage chargé de vérifier l’heure. Les informations d’horodatage sont incluses dans le fichier AIR. Un fichier AIR comprenant un horodatage vérifié peut être installé à tout moment par la suite. Si l’outil ADT ne parvient pas à se connecter au serveur d’horodatage, la création du package est annulée. Vous pouvez ignorer l’option d’horodatage, mais sans horodatage, il devient impossible d’installer une application AIR une fois que le certificat utilisé pour signer le fichier d’installation est arrivé à expiration.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Vous devez utiliser le certificat d’origine pour signer un package créé pour mettre à jour une application AIR existante. Si vous avez renouvelé ce certificat, qu’il a expiré au cours des 180 derniers jours ou que vous souhaitez le remplacer, vous pouvez apposer une signature de migration. Dans ce cas, le fichier AIR est signé à l’aide des deux certificats, l’ancien et le nouveau. La commande

-migrate permet d’appliquer la signature de migration, comme indiqué à la

section « Commande ADT migrate » à la page 181.

Important : vous disposez d’un délai de 180 jours au maximum pour apposer la signature de migration une fois le certificat d’origine périmé. Sans cette signature, les utilisateurs existants doivent désinstaller leur application existante pour pouvoir installer la nouvelle version. Le délai ne s’applique qu’aux applications pour lesquelles l’espace de noms stipule AIR 1.5.3 ou une version ultérieure dans le fichier descripteur. Lorsque vous ciblez des versions antérieures du moteur d’exécution d’AIR, vous ne disposez d’aucun délai.

Les signatures de migration n’étaient pas prises en charge préalablement à AIR 1.1. Pour apposer une signature de migration, vous devez mettre en package une application à l’aide d’un kit de développement SDK version 1.1 ou ultérieure.

Les applications déployées à l’aide de fichiers AIR font partie du profil de bureau. Il est impossible d’utiliser l’outil ADT pour mettre en package un programme d’installation natif destiné à une application AIR si le fichier descripteur correspondant ne prend pas en charge le profil de bureau. Vous pouvez restreindre l’utilisation de ce profil à l’aide de l’élément

supportedProfiles dans le fichier descripteur de l’application. Voir « Profils de périphérique » à la

page 255 et « supportedProfiles » à la page 248.

Remarque : les paramètres du fichier descripteur d’application déterminent l’identité d’une application AIR et son chemin d’installation par défaut. Voir « Fichiers descripteurs d’applications AIR » à la page 215.

Identifiants d’éditeur

Depuis AIR 1.5.3, les identifiants d’éditeur sont obsolètes. Les nouvelles applications (publiées à l’origine avec AIR 1.5.3 ou version ultérieure) ne requièrent pas d’identifiant d’éditeur et ne doivent pas en spécifier.

Lors de la mise à jour d’applications publiées à l’aide des versions antérieures d’AIR, vous devez spécifier l’identifiant d’éditeur d’origine dans le fichier descripteur d’application, sans quoi la version installée de l’application et la version mise à jour sont traitées comme des applications différentes. Si vous utilisez un autre identifiant d’éditeur ou omettez la balise publisherID, l’utilisateur est contraint de désinstaller la version antérieure pour pouvoir installer la nouvelle.

Pour déterminer l’identifiant d’éditeur original, recherchez le fichier

publisherid dans le sous-répertoire META-

INF/AIR du répertoire d’installation de l’application originale. La chaîne que contient ce fichier correspond à l’identifiant d’éditeur. Le fichier descripteur de l’application doit stipuler le moteur d’exécution d’AIR 1.5.3 (ou version ultérieure) dans la déclaration d’espace de noms pour que vous puissiez stipuler manuellement l’identifiant d’éditeur.

Dans le cas des applications publiées avant AIR 1.5.3 (ou de celles publiées à l’aide du kit SDK AIR 1.5.3, mais dont l’espace de noms du descripteur spécifie une version antérieure d’AIR), un identifiant d’éditeur est calculé à partir du certificat de signature. Allié à l’identifiant d’application, l’identifiant d’éditeur permet de déterminer l’identité d’une application. S’il existe, l’identifiant d’éditeur est utilisé comme suit :

• Pour vérifier que le fichier AIR est une mise à jour et non une nouvelle application à installer

• Dans la clé de chiffrement destinée au magasin local chiffré

• Dans le chemin du répertoire de stockage d’application

• Dans la chaîne de connexion associée aux connexions locales

• Dans la chaîne d’identité destinée à appeler une application par le biais de l’API intégrée au navigateur d’AIR

• Dans l’OSID (définition d’interface de service ouverte) utilisée lors de la création de programmes d’installation/de

désinstallation personnalisés

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Préalablement à AIR 1.5.3, l’identifiant d’éditeur d’une application pouvait changer si vous aviez signé la mise à jour de celle-ci par le biais d’une signature de migration utilisant un certificat nouveau ou renouvelé. Toute modification de l’identifiant d’éditeur entraîne un changement de comportement de toute fonctionnalité AIR basée sur celui-ci. Il devient, par exemple, impossible d’accéder aux données stockées dans le magasin local chiffré et la chaîne de connexion associée à toute occurrence de Flash ou d’AIR qui crée une connexion locale à l’application doit contenir le nouvel identifiant.

Dans AIR 1.5.3 ou ultérieur, l’identifiant d’éditeur n’est pas fondé sur le certificat de signature et est uniquement affecté si la balise publisherID figure dans le descripteur d’application. Il est impossible de mettre à jour une application si l’identifiant d’éditeur spécifié pour le package AIR de mise à jour ne correspond pas à l’identifiant d’éditeur actif.

Mise en package avec l’outil ADT

L’outil de ligne de commande ADT d’AIR permet de mettre en package une application AIR. Avant la mise en package, il est nécessaire de compiler tout code ActionScript, MXML et code d’extension éventuel. Vous devez également disposer d’un certificat de signature du code.

Pour consulter des informations de référence détaillées sur les commandes et options de l’outil ADT, voir « Outil AIR

Developer (ADT) » à la page 173.

Création d’un package AIR

Pour créer un package AIR, utilisez la commande ADT package et définissez le type de cible sur air pour les versions validées.

adt -package -target air -storetype pkcs12 -keystore ../codesign.p12 myApp.air myApp-app.xml myApp.swf icons

L’exemple part du principe que le chemin d’accès à l’outil ADT figure dans la définition path de l’interface de commande de ligne de commande. (Pour plus d’informations, voir « Variables d’environnement path » à la page 317.)

Vous devez exécuter la commande à partir du répertoire qui contient les fichiers de l’application. Dans l’exemple illustré, les fichiers de l’application sont myApp-app.xml (fichier descripteur de l’application), myApp.swf et un répertoire d’icônes.

Si vous exécutez la commande comme indiqué, l’outil ADT vous invite à entrer le mot de passe associé au keystore. (Les caractères du mot de passe saisis ne sont pas toujours affichés. Appuyez simplement sur Entrée une fois la saisie terminée.)

Création d’un package AIR à partir d’un fichier AIRI

Créer et signer un fichier AIRI permet de créer un package AIR à installer :

adt -sign -storetype pkcs12 -keystore ../codesign.p12 myApp.airi myApp.air

Mise en package d’un programme d’installation natif de bureau

Depuis AIR 2, vous pouvez créer, à l’aide de l’outil ADT, des programmes d’installation d’application natifs destinés à distribuer des applications AIR. Vous pouvez, par exemple, créer un fichier d’installation EXE pour distribuer une application AIR sous Windows, un fichier d’installation DMG pour distribuer une application AIR sur Mac OS et, dans AIR 2.5 et AIR 2.6, un fichier d’installation DEB ou RPM pour distribuer une application AIR sous Linux.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Les applications installées par le biais d’un programme d’installation natif font partie du profil de bureau étendu. Il est impossible d’utiliser l’outil ADT pour mettre en package un programme d’installation natif destiné à une application AIR si le fichier descripteur correspondant ne prend pas en charge le profil étendu de bureau. Vous pouvez restreindre l’utilisation de ce profil à l’aide de l’élément

supportedProfiles dans le fichier descripteur de l’application. Voir

« Profils de périphérique » à la page 255 et « supportedProfiles » à la page 248.

Vous disposez de deux techniques de base pour créer une version du programme d’installation natif de l’application AIR :

• Vous pouvez créer le programme d’installation natif à partir du fichier descripteur de l’application et d’autres

fichiers sources (à savoir, des fichiers SWF, des fichiers HTML et d’autres actifs).

• Vous pouvez fonder le programme d’installation natif sur un fichier AIR ou un fichier AIRI.

Vous devez utiliser l’outil ADT sur le même système d’exploitation que celui du programme d’installation à créer. Par conséquent, pour créer un fichier EXE pour Windows, exécutez l’outil ADT sous Windows. Pour créer un fichier DMG pour Mac OS, exécutez l’outil ADT sur Mac OS. Pour créer un fichier DEB ou RPG pour Linux, exécutez l’outil ADT à partir du kit SDK d’AIR 2.6 sous Linux.

Lorsque vous créez un programme d’installation natif pour distribuer une application AIR, celle-ci possède les fonctionnalités suivantes :

• Elle peut lancer des processus natifs et communiquer avec eux, par le biais de la classe NativeProcess. Pour plus

d’informations, voir :

• Communication avec les processus natifs dans AIR (développeurs ActionScript)

• Communication avec les processus natifs dans AIR (développeurs HTML)

• Elle peut faire appel à des extensions natives.

• Elle peut ouvrir tout fichier dans l’application système définie par défaut à cet effet à l’aide de la méthode

File.openWithDefaultApplication(), quel que soit le type du fichier. (Les applications qui ne sont pas

installées à l’aide d’un programme d’installation natif sont soumises à des restrictions. Pour plus d’informations, voir l’entrée

File.openWithDefaultApplication() dans la référence du langage.)

La mise en package sous forme de programme d’installation natif entraîne toutefois la perte de certains avantages qui caractérisent le format de fichier AIR. Il est alors impossible de distribuer un fichier unique sur tous les ordinateurs de bureau. La fonction de mise à jour intégrée (ainsi que la structure du programme de mise à jour) ne fonctionnent pas.

Lorsque l’utilisateur double-clique sur le fichier du programme d’installation natif, l’application AIR est installée. Si la version requise d’Adobe AIR n’est pas déjà installée sur la machine, le programme d’installation la télécharge du réseau et l’installe. En l’absence d’une connexion réseau permettant d’obtenir la version appropriée d’Adobe AIR (si nécessaire), l’installation échoue. L’installation échoue également si le système d’exploitation n’est pas pris en charge dans Adobe AIR 2.

Remarque : si vous souhaitez qu’un fichier puisse être exécuté dans l’application installée, assurez-vous qu’il est exécutable sur le système de fichiers lors de la mise en package de l’application. (Sous Mac et Linux, vous disposez de chmod pour définir l’indicateur executable, le cas échéant.)

Création d’un programme d’installation natif à partir des fichiers sources de l’application

Pour créer un programme d’installation natif à partir des fichiers sources de l’application, utilisez la commande

package en respectant la syntaxe suivante (sur une même ligne de commande) :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

adt -package AIR_SIGNING_OPTIONS

-target native [WINDOWS_INSTALLER_SIGNING_OPTIONS] installer_file app_xml [file_or_dir | -C dir file_or_dir | -e file dir ...] ...

La syntaxe est identique à celle permettant de mettre en package un fichier AIR (sans programme d’installation natif), à quelques exceptions près :

• Vous ajoutez l’option -target native à la commande. (Si vous spécifiez -target air, l’outil ADT génère un

fichier AIR plutôt qu’un fichier d’installation natif.)

• Vous spécifiez le fichier DMG ou EXE cible en tant que fichier de programme d’installation (installer_file).

• Sous Windows, vous pouvez ajouter un deuxième jeu d’options de signature, indiquées sous la forme

[WINDOWS_INSTALLER_SIGNING_OPTIONS] dans la syntaxe. Cette étape est facultative. Sous Windows, outre la

signature du fichier AIR, vous pouvez signer le fichier d’installation. Utilisez la même syntaxe pour définir le type de certificat et l’option de signature que pour signer le fichier AIR (voir « Options de signature du code de l’outil

ADT » à la page 187). Vous pouvez signer le fichier AIR et le fichier d’installation à l’aide d’un même certificat ou

de certificats différents. Lorsque l’utilisateur télécharge un fichier d’installation Windows signé du Web, Windows se fonde sur le certificat pour identifier la source du fichier.

Pour plus d’informations sur les options ADT autres que

-target, voir « Outil AIR Developer (ADT) » à la page 173.

L’exemple suivant crée un fichier DMG (fichier d’installation natif réservé à Mac OS) :

adt -package

-storetype pkcs12

-keystore myCert.pfx

-target native myApp.dmg application.xml index.html resources

L’exemple suivant crée un fichier EXE (fichier d’installation natif réservé à Windows) :

adt -package

-storetype pkcs12

-keystore myCert.pfx

-target native myApp.exe application.xml index.html resources

L’exemple suivant crée un fichier EXE et le signe :

adt -package

-storetype pkcs12

-keystore myCert.pfx

-target native

-storetype pkcs12

-keystore myCert.pfx myApp.exe application.xml index.html resources

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Création d’un programme d’installation natif pour une application faisant appel à des extensions natives

Vous pouvez créer un programme d’installation natif à partir des fichiers sources de l’application et des packages d’extensions natives dont l’application a besoin. Utilisez la commande

-package en respectant la syntaxe suivante (sur

une seule ligne de commande) :

adt -package AIR_SIGNING_OPTIONS

-migrate MIGRATION_SIGNING_OPTIONS

-target native [WINDOWS_INSTALLER_SIGNING_OPTIONS] installer_file app_xml

-extdir extension-directory [file_or_dir | -C dir file_or_dir | -e file dir ...] ...

Cette syntaxe est identique à celle utilisée pour la mise en package d’un programme d’installation natif, avec deux options supplémentaires. Utilisez l’option contenant les fichiers ANE (extensions natives) qu’utilise l’application. Utilisez l’indicateur facultatif les paramètres

MIGRATION_SIGNING_OPTIONS en vue de signer la mise à jour d’une application avec une signature de

-extdir extension-directory en vue de spécifier le répertoire

-migrate avec

migration lorsque le certificat principal de signature de code est différent de celui utilisé par la version précédente. Pour plus d’informations, voir « Signature d’une version mise à jour d’une application AIR » à la page 209.

Pour plus d’informations sur les options d’ADT, voir « Outil AIR Developer (ADT) » à la page 173.

L’exemple suivant crée un fichier DMG (fichier de programme d’installation pour Mac OS) pour une application faisant appel à des extensions natives :

adt -package

-storetype pkcs12

-keystore myCert.pfx

-target native myApp.dmg application.xml

-extdir extensionsDir index.html resources

Création d’un programme d’installation natif à partir d’un fichier AIR ou AIRI

L’outil ADT permet de générer un fichier d’installation natif à partir d’un fichier AIR ou AIRI. Pour créer un fichier d’installation natif à partir d’un fichier AIR, utilisez la commande

-package de l’outil ADT en respectant la syntaxe

suivante (sur une même ligne de commande) :

adt -package

-target native [WINDOWS_INSTALLER_SIGNING_OPTIONS] installer_file air_file

Cette syntaxe est identique à celle permettant de créer un fichier d’installation natif à partir des fichiers sources de l’application AIR, à quelques exceptions près :

• Comme source, vous spécifiez un fichier AIR, et non un fichier descripteur d’application et d’autres fichiers sources

de l’application AIR.

• Ne spécifiez pas d’options de signature du fichier AIR car il est déjà signé.

Pour créer un fichier d’installation natif à partir d’un fichier AIRI, utilisez la commande

-package de l’outil ADT en

respectant la syntaxe suivante (sur une même ligne de commande) :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

adt AIR_SIGNING_OPTIONS

-package

-target native [WINDOWS_INSTALLER_SIGNING_OPTIONS] installer_file airi_file

Cette syntaxe est identique à celle permettant de créer un fichier d’installation natif à partir d’un fichier AIR, à quelques exceptions près :

• Vous spécifiez un fichier AIRI comme source.

• Vous spécifiez des options de signature pour l’application AIR cible.

L’exemple suivant crée un fichier DMG (fichier d’installation natif sur Mac OS) à partir d’un fichier AIR :

adt -package -target native myApp.dmg myApp.air

L’exemple suivant crée un fichier EXE (fichier d’installation natif sous Windows) à partir d’un fichier AIR :

adt -package -target native myApp.exe myApp.air

L’exemple suivant crée un fichier EXE (à partir d’un fichier AIR) et le signe :

adt -package -target native -storetype pkcs12 -keystore myCert.pfx myApp.exe myApp.air

L’exemple suivant crée un fichier DMG (fichier d’installation natif sur Mac OS) à partir d’un fichier AIRI :

adt -storetype pkcs12 -keystore myCert.pfx -package -target native myApp.dmg myApp.airi

L’exemple suivant crée un fichier EXE (fichier d’installation natif sous Windows) à partir d’un fichier AIRI :

adt -storetype pkcs12 -keystore myCert.pfx -package -target native myApp.exe myApp.airi

L’exemple suivant crée un fichier EXE (basé sur un fichier AIRI) et applique une signature AIR et une signature Windows native :

adt -package -storetype pkcs12 -keystore myCert.pfx -target native -storetype pkcs12 -keystore myCert.pfx myApp.exe myApp.airi

Mise en package d’un paquet de moteur d’exécution captif pour des ordinateurs de bureau

Un paquet de moteur d’exécution captif est un package qui inclut le code de votre application, ainsi qu’une version dédiée du moteur d’exécution. Une application mise en package de cette manière fait appel au moteur d’exécution du paquet et non au moteur d’exécution partagé installé sur l’ordinateur d’un utilisateur.

Le paquet produit est un dossier autonome de fichiers d’application sur Windows et un paquet .app sur Mac OS. Vous devez produire le paquet correspondant à un système d’exploitation cible lors de l’exécution de ce système d’exploitation. (Il est possible d’utiliser une machine virtuelle, telle que VMWare, pour exécuter plusieurs systèmes d’exploitation sur un même ordinateur.)

Vous pouvez exécuter l’application à partir de ce dossier ou paquet sans installation.

Avantages

• Création d’une application autonome

• Aucun accès Internet requis pour l’installation

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

• Indépendance de l’application par rapport aux mises à jour du moteur d’exécution

• Possibilité aux entreprises de certifier l’application spécifique et l’association de moteurs d’exécution

• Prise en charge du modèle traditionnel de déploiement de logiciels

• Aucune redistribution individuelle du moteur d’exécution requise

• Possibilité d’utiliser l’API NativeProcess

• Possibilité d’utiliser des extensions natives

• Possibilité d’utiliser la fonction File.openWithDefaultApplication() sans aucune restriction

• Possibilité d’exécution à partir d’un périphérique USB ou d’un disque optique sans aucune installation

Inconvénients

• Principaux correctifs de sécurité publiés par Adobe non automatiquement disponibles aux utilisateurs

• Impossibilité d’utiliser le format de fichier .air

• Création nécessaire d’un programme d’installation propre, le cas échéant

• API et structure de mise à jour AIR non prises en charge

• API propre au navigateur AIR permettant d’installer et de lancer une application AIR à partir d’une page Web non

prise en charge

• Sous Windows, l’enregistrement du fichier doit être géré par le programme d’installation de l’utilisateur

• Plus grande empreinte disque de l’application

Création d’un paquet de moteur d’exécution captif sous Windows

Pour créer un paquet de moteur d’exécution captif sous Windows, vous devez mettre en package l’application lors de l’exécution du système d’exploitation Windows. Mettez en package l’application à l’aide de la cible bundle de l’outil ADT :

adt -package

-keystore ..\cert.p12 -storetype pkcs12

-target bundle myApp myApp-app.xml myApp.swf icons resources

Cette commande crée le paquet dans un répertoire appelé myApp. Ce répertoire contient les fichiers pour votre application, ainsi que les fichiers du moteur d’exécution. Vous pouvez exécuter le programme directement à partir du dossier. Néanmoins, pour créer une entrée de menu de programme, ou enregistrer les types de fichiers ou les gestionnaires de modèles d’URI, vous devez créer un programme d’installation qui définit les entrées de registre requises. Le kit SDK d’AIR n’inclut aucun outil permettant de créer ces programmes d’installation, mais diverses options tierces sont disponibles, notamment des kits d’outils de programmes d’installation Open Source gratuits.

Vous pouvez signer l’exécutable natif sous Windows en spécifiant un deuxième ensemble d’options de signature après l’entrée associé à utiliser lors de l’application de la signature Windows native. (Il est possible d’utiliser un certificat de signature de code AIR.) Seul l’exécutable principal est signé. Tout exécutable supplémentaire mis en package avec votre application n’est pas signé par ce processus.

-target bundle sur la ligne de commande. Ces options de signature identifient la clé privée et le certificat

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Association de types de fichiers

Pour associer votre application à des types de fichiers publics ou personnalisés sous Windows, votre programme d’installation doit définir les entrées de registre appropriées. Les types de fichiers doivent également être répertoriés dans l’élément fileTypes du fichier descripteur de l’application.

Pour plus d’informations sur les types de fichiers Windows, voir MSDN Library: File Types and File Associations (disponible en anglais uniquement).

Enregistrement du gestionnaire d’URI

Afin que votre application puisse prendre en charge le lancement d’une URL via un modèle d’URI donné, votre programme d’installation doit définir les entrées de registre requises.

Pour plus d’informations sur l’enregistrement d’une application en vue de gérer un modèle d’URI, voir MSDN Library:

Registering an Application to a URL Protocol (disponible en anglais uniquement).

Création d’un paquet de moteur d’exécution captif sous Mac OS X

Pour créer un paquet de moteur d’exécution captif sous Mac OS X, vous devez mettre en package l’application lors de l’exécution du système d’exploitation Macintosh. Mettez en package l’application à l’aide de la cible bundle de l’outil ADT :

adt -package

-keystore ../cert.p12 -storetype pkcs12

-target bundle myApp.app myApp-app.xml myApp.swf icons resources

Cette commande crée le paquet d’application appelé myApp.app. Ce paquet contient les fichiers pour votre application, ainsi que les fichiers du moteur d’exécution. Vous pouvez exécuter l’application en cliquant deux fois sur l’icône myApp.app, puis l’installer en la faisant glisser vers l’emplacement approprié, par exemple vers le dossier Applications. Néanmoins, pour enregistrer les types de fichiers ou les gestionnaires de modèles d’URI, vous devez modifier le fichier de liste de propriétés à l’intérieur du package d’application.

Pour la distribution, vous pouvez créer un fichier d’image de disque (.dmg). Le kit SDK d’Adobe AIR ne fournit aucun outil permettant de créer un fichier dmg pour un paquet de moteur d’exécution captif.

Association de types de fichiers

Pour associer votre application à des types de fichiers publics ou personnalisés sous Mac OS X, vous devez modifier le fichier info.plist dans le paquet afin de définir la propriété CFBundleDocumentTypes. Voir Mac OS X Developer

Library: Information Property List Key Reference, CFBundleURLTypes (disponible en anglais uniquement).

Enregistrement du gestionnaire d’URI

Afin que votre application puisse prendre en charge le lancement d’une URL via un modèle d’URI donné, vous devez modifier le fichier info.plist file dans le paquet en vue de définir la propriété CFBundleURLTypes. Voir Mac OS X

Developer Library: Information Property List Key Reference, CFBundleDocumentTypes (disponible en anglais

uniquement).

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Distribution d’un package AIR pour ordinateur de bureau

Vous pouvez distribuer une application AIR sous forme de package AIR contenant le code de l’application et tous ses actifs. Vous pouvez distribuer ce package via les méthodes standard : téléchargement, courrier électronique ou support physique comme le CD-ROM. Les utilisateurs peuvent installer l’application en double-cliquant sur le fichier AIR. L’API d’AIR intégrée au navigateur (bibliothèque ActionScript Web) permet aux utilisateurs d’installer l’application AIR (ainsi qu’Adobe® AIR®, le cas échéant) par le biais d’un lien unique sur une page Web.

Il est également possible de mettre en package et distribuer une application AIR sous forme de programme d’installation natif (en d’autres termes, fichier EXE sous Windows, fichier DMG sous Mac et fichier DEB ou RPM sous Linux). Vous pouvez distribuer et installer les packages d’installation natifs conformément aux conventions appropriées de la plate-forme. En distribuant l’application sous forme de package natif, vous perdez toutefois certains avantages du format de fichier AIR. Il devient ainsi impossible de faire appel à la structure de mise à jour d’AIR et à l’API intégrée au navigateur ou d’utiliser un fichier d’installation unique sur la plupart des plates-formes.

Installation et exécution d’une application AIR à partir du bureau

Il vous suffit d’envoyer le fichier AIR au destinataire. Vous pouvez par exemple l’envoyer sous forme de pièce jointe dans un courrier électronique, ou sous forme de lien dans une page Web.

Une fois que l’utilisateur a téléchargé l’application AIR, il suit les instructions suivantes pour l’installer :

1 Double-cliquez sur le fichier AIR.

Le logiciel Adobe AIR doit être déjà installé sur l’ordinateur.

2 Dans la fenêtre d’installation, conservez les paramètres par défaut sélectionnés, puis cliquez sur Continuer.

Sous Windows, AIR effectue automatiquement les opérations suivantes :

• Installation de l’application dans le répertoire Program Files

• Création d’un raccourci sur le bureau pour ouvrir l’application

• Création d’un raccourci dans le menu Démarrer

• Ajout d’une entrée dans l’application Ajout/Suppression de programmes du Panneau de configuration

Sous Mac OS, l’application est automatiquement ajoutée dans le répertoire Applications.

Si l’application existe déjà, le programme d’installation donne à l’utilisateur le choix d’ouvrir la version existante de l’application ou de mettre celle-ci à jour grâce au fichier AIR téléchargé. Le programme d’installation identifie l’application au moyen de l’ID d’application et de l’ID d’éditeur qui sont contenus dans le fichier AIR.

3 Une fois que vous avez terminé l’installation, cliquez sur Terminer.

S’il utilise Mac OS, l’utilisateur a besoin des privilèges système appropriés pour installer une version de mise à jour d’une application dans le répertoire de l’application. S’il utilise Windows ou Linux, l’utilisateur doit disposer de privilèges d’administrateur.

Une application peut également installer une nouvelle version via ActionScript ou JavaScript. Pour plus d’informations, voir « Mise à jour des applications AIR » à la page 269.

Une fois l’application AIR installée, l’utilisateur se contente de double-cliquer sur l’icône de l’application pour l’exécuter, à l’instar de n’importe quelle application de bureau.

• Sous Windows, double-cliquez sur l’icône de l’application (installée sur le Bureau ou dans un dossier) ou

sélectionnez l’application à partir du menu Démarrer.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

• Sous Linux, double-cliquez sur l’icône de l’application (installée sur le Bureau ou dans un dossier) ou sélectionnez

l’application dans le menu.

• Sous Mac OS, double-cliquez sur l’application dans le dossier où elle a été installée. Le répertoire d’installation par

défaut est /Applications.

Remarque : Seules les applications AIR développées pour AIR 2.6 ou les versions antérieures peuvent être installées sous Linux.

La fonctionnalité d’installation transparente d’AIR permet à un utilisateur d’installer une application AIR en cliquant sur un lien dans une page Web. La fonctionnalité d’appel du navigateur d’AIR permet à un utilisateur d’exécuter une application AIR installée en cliquant sur un lien dans une page Web. Ces fonctionnalités sont décrites dans la section suivante.

Installation et exécution d’une application de bureau AIR à partir d’une page Web

L’API AIR intégrée au navigateur permet d’installer et d’exécuter une application AIR à partir d’une page Web. Elle réside dans une bibliothèque SWF, air.swf, qui est hébergée par Adobe. Le kit SDK d’AIR contient un exemple d’application « badge » qui utilise cette bibliothèque pour installer, mettre à jour ou lancer une application AIR (ainsi que le moteur d’exécution, le cas échéant). Vous pouvez modifier cet exemple d’application ou créer une application Web badge qui utilise directement la bibliothèque en ligne air.swf.

Il est possible d’installer toute application AIR par le biais d’un badge de page Web. Toutefois, seules les applications dont le fichier descripteur contient l’élément peuvent être lancées par un badge Web.

Voir aussi

« API intégrée au navigateur et stockée dans le fichier AIR.SWF » à la page 260

Déploiement en entreprise sur des ordinateurs de bureau

Les administrateurs peuvent installer le moteur d’exécution d’Adobe AIR et les applications AIR en toute transparence à l’aide d’outils de déploiement de postes de travail standard. Ces administrateurs peuvent exécuter les tâches suivantes :

• Installation en mode silencieux du moteur d’exécution d’Adobe AIR à l’aide d’outils tels que Microsoft SMS, Tivoli

d’IBM ou de tout autre outil de déploiement permettant des installations automatiques au moyen d’un programme d’amorçage

• Installation en mode silencieux de l’application AIR à l’aide des mêmes outils utilisés pour déployer le moteur

d’exécution

Pour plus d’informations, voir le Guide de l’administrateur Adobe AIR

(http://www.adobe.com/go/learn_air_admin_guide_fr).

Journaux d’installation sur des ordinateurs de bureau

Des journaux d’installation sont enregistrés lors de l’installation du moteur d’exécution d’AIR ou d’une application AIR. Vous pouvez les consulter pour déterminer la cause de tout problème d’installation ou de mise à jour.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications de bureau AIR

Les fichiers journaux sont créés aux emplacements suivants :

• Mac : journal système standard (/private/var/log/system.log)

Pour afficher le journal système Mac, ouvrez l’application Console (qui réside généralement dans le dossier Utilitaires).

• Windows XP : C:\Documents and Settings\<nom d'utilisateur>\Local Settings\Application

Data\Adobe\AIR\logs\Install.log

• Windows Vista, Windows 7 : C:\Users\<nom

d'utilisateur>\AppData\Local\Adobe\AIR\logs\Install.log

• Linux : /home/<nom d'utilisateur>/.appdata/Adobe/AIR/Logs/Install.log

Remarque : ces fichiers n’étaient pas créés dans les versions d’AIR antérieures à AIR 2.

Dernière mise à jour le 14/11/2013

Chapitre 7 : Développement d’applications AIR pour périphériques mobiles

Les applications AIR pour périphériques mobiles sont déployées en tant qu’applications natives. Elles utilisent le format applicatif du périphérique, plutôt que le format AIR. AIR prend actuellement en charge les packages APK d’Android et IPA d’iOS. Une fois la version commerciale du package de l’application créée, vous pouvez distribuer l’application par le biais du mécanisme standard de la plate-forme. Pour Android, il s’agit généralement d’Android Market, pour iOS, de l’App Store d’Apple.

Vous disposez du kit SDK d’AIR et de Flash Professional, Flash Builder ou d’un autre outil de développement ActionScript pour créer des applications AIR pour périphériques mobiles. Les applications AIR de type HTML ne sont actuellement pas prises en charge.

Remarque : la tablette Research In Motion (RIM) BlackBerry Playbook fournit son propre kit SDK pour le développement d’AIR. Pour plus d’informations sur le développement de Playbook, voir RIM: BlackBerry Tablet OS

Development (disponible en anglais uniquement).

Remarque : Ce document décrit la procédure de développement d’applications iOS par le biais du kit SDK d’AIR 2.6 ou d’une version ultérieure. Il est possible d’installer les applications créées avec AIR 2.6 et les versions ultérieures sur les dispositifs iPhone 3G, iPhone 4 et iPad exécutant iOS 4 ou une version ultérieure. Pour développer une application AIR destinée aux versions antérieures d’iOS, vous devez utiliser l’outil Packager for iPhone AIR 2, comme décrit dans le manuel Création d’applications iPhone.

Pour plus d’informations sur les meilleures pratiques en matière de confidentialité, voir Guide de confidentialité du

SDK Adobe AIR.

Pour plus d’informations sur la configuration système requise pour exécuter les applications AIR, voir Configuration

requise.

Configuration de l’environnement de développement

Parallèlement à la configuration de l’environnement de développement AIR, Flex et Flash standard, il est nécessaire de configurer les plates-formes mobiles. (Pour plus d’informations sur la configuration de l’environnement de développement AIR de base, voir « Outils de la plate-forme Adobe Flash pour le développement AIR » à la page 17.)

Configuration d’Android

Aucune configuration spéciale n’est normalement requise pour Android dans AIR 2.6+. L’outil ADB d’Android est inclus dans le kit SDK d’AIR (dans le dossier lib/android/bin). Le kit SDK d’AIR fait appel à l’outil ADB pour installer, désinstaller et exécuter un package d’application sur un périphérique. L’outil ADB permet également d’afficher les journaux système. Pour créer et exécuter un émulateur Android, vous devez télécharger le kit SDK d’Android distinct.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Si votre application ajoute des éléments à l’élément <manifestAdditions> dans le descripteur d’application que la version actuelle d’AIR ne reconnaît pas comme valides, vous devez installer une version plus récente du SDK d’Android. Définissez la variable d’environnement AIR_ANDROID_SDK_HOME ou le paramètre de la ligne de commande kit SDK pour valider les entrées dans l’élément

Dans AIR 2.5, vous devez télécharger un exemplaire distinct du kit SDK d’Android à partir de Google. Vous pouvez définir la variable d’environnement AIR_ANDROID_SDK_HOME de sorte à référencer le dossier du kit SDK d’Android. Si vous ne définissez pas cette variable d’environnement, vous devez spécifier le chemin d’accès au kit SDK d’Android dans l’argument

-platformsdk sur le chemin de fichier du kit SDK. L’outil de mise en package d’AIR, ADT, fait appel à ce <manifestAdditions>.

-platformsdk sur la ligne de commande ADT.

Voir aussi

« Variables d’environnement ADT » à la page 196

« Variables d’environnement path » à la page 317

Configuration d’iOS

Pour installer et tester une application iOS sur un périphérique et la distribuer, vous devez appartenir au programme iOS Developer d’Apple (service payant). Une fois membre du programme iOS Developer, vous pouvez accéder au portail iOS Provisioning Portal, où vous pouvez obtenir d’Apple les éléments et fichiers suivants, dont vous devez disposer pour installer une application sur un périphérique à des fins de test et de distribution ultérieure :

• Certificats de développement et de distribution

• ID d’application

• Fichiers de configuration pour le développement et la distribution d’applications

Considérations liées à la conception d’applications mobiles

Le contexte d’exploitation et les caractéristiques physiques des périphériques mobiles nécessitent de porter une attention toute particulière au codage et à la conception. Il est, par exemple, déterminant de rationaliser le code pour assurer une exécution aussi rapide que possible. Il est bien évident que l’optimisation du code a ses limites. Une conception intelligente qui prend en compte les restrictions du périphérique permet également d’éviter que la présentation visuelle ne sollicite trop le système de rendu.

Code

Bien qu’une exécution plus rapide du code constitue toujours un avantage, la vitesse réduite du processeur de la plupart des périphériques mobiles rationalise l’investissement en temps que représente l’écriture de code minimaliste. Par ailleurs, les périphériques mobiles sont quasiment toujours alimentés par batterie. Obtenir un résultat identique en réduisant la puissance de traitement requise utilise moins de batterie.

Création

La taille d’écran réduite, le mode d’interaction par écran tactile, voire l’environnement en évolution constante d’un utilisateur mobile sont autant de facteurs à prendre en compte lors de la conception de l’expérience utilisateur de l’application.

Code et création conjoints

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Si l’application fait appel à l’animation, l’optimisation du rendu joue un rôle déterminant. Dans certains cas, l’optimisation du code n’est toutefois pas suffisante. Vous devez concevoir les aspects visuels de l’application de sorte à assurer un rendu performant par le code.

D’importantes techniques d’optimisation sont passées en revue dans le manuel Optimisation de contenu mobile pour

la plate-forme Adobe Flash. Les techniques décrites dans ce manuel s’appliquent à tout contenu Flash et AIR, mais

jouent un rôle déterminant dans le développement d’applications pour périphériques mobiles performantes.

• Paul Trani : Tips and Tricks for Mobile Flash Development (disponible en anglais uniquement)

• roguish : GPU Test App AIR for Mobile (disponible en anglais uniquement)

• Jonathan Campos : Optimization Techniques for AIR for Android apps (disponible en anglais uniquement)

• Charles Schulze : AIR 2.6 Game Development: iOS included (disponible en anglais uniquement)

Cycle de vie d’une application

Lorsque la cible d’action passe d’une application à une autre, AIR fait passer la cadence à 4 images/s et désactive le rendu des graphiques. Une cadence inférieure se traduit souvent par l’interruption des connexions socket et du réseau de diffusion en continu. Si l’application n’utilise pas ces types de connexion, vous pouvez réduire plus encore la cadence.

Au moment opportun, vous devez arrêter la lecture de l’audio et supprimer les écouteurs associés aux capteurs de géolocalisation et de l’accéléromètre. L’objet NativeApplication AIR distribue des événements d’activation et de désactivation. Ces événements permettent de gérer la transition entre l’état actif et l’état d’arrière-plan.

La plupart des systèmes d’exploitation mobiles arrêtent les applications qui s’exécutent en arrière-plan sans avertissement. Grâce à l’enregistrement régulier de l’état d’une application, celle-ci devrait pouvoir restaurer ellemême un état satisfaisant, qu’il s’agisse de la réactivation de l’état actif à partir d’une exécution en arrière-plan ou d’un nouveau lancement.

Densité des informations

En dépit d’une densité (nombre de pixels par pouce) supérieure, la taille physique de l’écran des périphériques mobiles est inférieure à celle d’un ordinateur de bureau. Une même taille de police produit des lettres de taille physique inférieure sur un écran de périphérique mobile que sur un ordinateur de bureau. Par souci de lisibilité, il est souvent nécessaire d’utiliser une taille de police supérieure. En règle générale, 14 points est la plus petite taille de police qu’un utilisateur puisse facilement lire.

Les périphériques mobiles sont souvent utilisés en cours de déplacement et dans des environnements mal éclairés. Faites preuve de réalisme pour évaluer le volume d’informations qu’il est possible d’afficher sans perte de lisibilité. Cette valeur est probablement inférieure à celle d’un écran d’ordinateur de bureau aux dimensions identiques en pixels.

Gardez également à l’esprit le fait que lorsqu’un utilisateur touche l’écran, il masque du doigt ou de la main une partie de ce dernier. Placez les éléments interactifs sur les côtés et au bas de l’écran si l’utilisateur ne se contente pas de les toucher momentanément.

Saisie de texte

La plupart des périphériques gèrent la saisie de texte par le biais d’un clavier virtuel. Souvent peu pratiques à utiliser, les claviers virtuels masquent une partie de l’écran. A l’exception des touches programmables, évitez de faire appel aux événements de clavier.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Envisagez de substituer d’autres solutions aux champs de texte de saisie. Il est, par exemple, inutile d’inviter l’utilisateur à entrer une valeur numérique dans un champ de texte. Proposez deux boutons pour augmenter ou réduire la valeur.

Touches programmables

Les périphériques mobiles comportent un nombre divers de touches programmables, c’est-à-dire des boutons que vous pouvez programmer pour leur affecter différentes fonctions. Respectez les conventions de la plate-forme lorsque vous programmez ces touches dans l’application.

Changements d’orientation de l’écran

Un contenu mobile peut être visualisé en mode portrait ou paysage. Considérez comment l’application gère les changements d’orientation de l’écran. Pour plus d’informations, voir Orientation de la scène.

Baisse de la luminosité de l’écran

AIR ne désactive pas automatiquement la baisse de la luminosité de l’écran en cours de lecture vidéo. Vous disposez de la propriété d’énergie du périphérique. (Sur certaines plates-formes, vous devez demander les autorisations appropriées pour que cette fonctionnalité fonctionne.)

systemIdleMode de l’objet NativeApplication AIR pour contrôler l’activation du mode d’économie

Appels téléphoniques entrants

Le moteur d’exécution d’AIR coupe automatiquement le son lorsque l’utilisateur effectue ou reçoit un appel téléphonique. Sous Android, définissez l’autorisation Android READ_PHONE_STATE dans le descripteur de l’application si celle-ci lit l’audio lorsqu’elle s’exécute en arrière-plan. Android interdit sinon au moteur d’exécution de détecter les appels téléphoniques et de couper le son automatiquement. Voir « Autorisations Android » à la page 80.

Cibles tactiles

Tenez compte de la taille des cibles tactiles lorsque vous concevez les boutons et autres éléments de l’interface utilisateur touchés par l’utilisateur. Assurez-vous que la taille de ces éléments est suffisamment élevée pour que l’utilisateur puisse facilement les activer du doigt sur un écran tactile. Veillez également à ménager un espace suffisant entre cibles tactiles. Pour un écran de téléphone à résolution élevée standard, la superficie d’une cible tactile doit mesurer environ 44 pixels sur 57 pixels.

Taille d’installation d’un package d’application

Les périphériques mobiles disposent généralement d’un espace de stockage considérablement plus réduit que les ordinateurs de bureau pour installer applications et données. Réduisez la taille d’un package en supprimant les actifs et bibliothèques inutilisés.

Sous Android, le package d’une application n’est pas extrait dans des fichiers distincts lors de l’installation de cette dernière. Les actifs sont décompressés dans un espace de stockage temporaire lorsqu’il est nécessaire d’y accéder. Pour réduire l’encombrement mémoire des actifs décompressés, fermez les flux d’URL et de fichier, une fois le chargement des actifs terminé.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Accès au système de fichiers

Les restrictions relatives au système de fichiers varient selon le système d’exploitation mobile. Elles diffèrent souvent des restrictions imposées par les systèmes d’exploitation de bureau. L’emplacement d’enregistrement des fichiers et données risque par conséquent de varier selon la plate-forme.

Les variations en matière de système de fichiers ont pour conséquence que les raccourcis associés aux répertoires communs fournis par la classe File d’AIR ne sont pas toujours disponibles. Le tableau suivant indique les raccourcis disponibles sous Android et iOS :

Android iOS

File.applicationDirectory Lecture seule via une URL (et non le

chemin natif)

File.applicationStorageDirectory Disponible Disponible

File.cacheDirectory Disponible Disponible

File.desktopDirectory Racine de la carte SD Non disponible

File.documentsDirectory Racine de la carte SD Disponible

File.userDirectory Racine de la carte SD Non disponible

File.createTempDirectory() Disponible Disponible

File.createTempFile() Disponible Disponible

Lecture seule

Les directives d’Apple concernant les applications iOS définissent des règles spécifiques concernant les emplacements de stockage à utiliser pour les fichiers dans différentes situations. Par exemple, l’une des directives est que seuls les fichiers contenant des données saisies par l’utilisateur ou des données qui ne peuvent pas être générées ou téléchargées à nouveau doivent être stockées dans le répertoire désigné pour la sauvegarde à distance. Pour plus d’informations sur la conformité aux directives d’Apple sur la sauvegarde des fichiers et la mise en cache, voir Contrôle de la sauvegarde et de la mise en cache des fichiers.

Composants de l’interface utilisateur

Adobe a développé une version de la structure d’application Flex optimisée pour les plates-formes mobiles. Pour plus d’informations, voir Développement d’applications mobiles avec Flex et Flash Builder.

Des projets de composants à usage communautaire adaptés aux applications mobiles sont également disponibles. Parmi ces API figurent :

• Josh Tynjala : Feathers UI controls for Starling (en anglais uniquement)

• Skinnable version of Minimal Comps (Derrick Grigg) (disponible en anglais uniquement)

• as3flobile components (Todd Anderson) (disponible en anglais uniquement)

Rendu des graphiques par accélération matérielle via l’API Stage3D

A partir d’AIR 3.2, AIR for Mobile prend en charge le rendu des graphiques par accélération matérielle via l’API Stage 3D. Les API ActionScript Stage3D sont un ensemble d’API à accélération matérielle par GPU permettant d’utiliser des fonctionnalités 2D et 3D avancées. Ces API de bas niveau permettent aux développeurs de tirer profit de l’accélération matérielle par GPU pour augmenter les performances de façon significative. Il est également possible d’utiliser des moteurs de jeu prenant en charge les API ActionScript Stage3D.

Pour plus d’informations, voir Moteurs de jeu, 3D et Stage 3D.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Lissage vidéo

Afin d’améliorer les performances, le lissage vidéo est désactivé sur AIR.

Fonctions natives

AIR 3.0+

De nombreuses plates-formes mobiles proposent des fonctions qui ne sont pas encore accessibles via l’API AIR standard. A partir d’AIR 3, vous pouvez étendre AIR avec vos propres bibliothèques de code natives. Ces bibliothèques d’extensions natives peuvent accéder aux fonctions disponibles sur le système d’exploitation, voire même aux fonctions propres à un périphérique donné. Il est possible d’écrire les extensions natives en langage C sur iOS, et en langage Java ou C sur Android. Pour plus d’informations sur le développement d’extensions natives, voir Présentation des extensions natives pour Adobe AIR.

Flux de travail de création d’une application AIR pour périphériques mobiles

Le flux de travail de création d’une application AIR pour périphériques mobiles (ou autres types de périphériques) s’apparente généralement au flux de travail de création d’applications de bureau. Les principales différences sont liées aux phases de mise en package, de débogage et d’installation d’une application. Les applications AIR for Android utilisent, par exemple, le format de package APK natif d’Android au lieu du format de package d’AIR. Par conséquent, elles font également appel aux mécanismes d’installation et de mise à jour standard d’Android.

AIR for Android

Les étapes ci-dessous décrivent une procédure de développement typique d’une application AIR for Android :

• Programmez le code en ActionScript ou MXML.

• Créez un fichier descripteur d’application AIR (utilisez l’espace de noms 2.5 ou ultérieur).

• Compilez l’application.

• Mettez en package l’application au format Android (.apk).

• Installez le moteur d’exécution AIR sur le périphérique ou l’émulateur Android (si vous utilisez un moteur

d’exécution externe ; le moteur d’exécution captif est la valeur par défaut dans AIR 3.7 et versions ultérieures).

• Installez l’application sur le périphérique (ou l’émulateur Android).

• Lancez l’application sur le périphérique.

Pour exécuter cette procédure, vous disposez d’Adobe Flash Builder, d’Adobe Flash Professional CS5 ou des outils de ligne de commande.

Une fois l’application AIR terminée et mise en package au format APK, vous pouvez la proposer à Android Market ou la distribuer par un autre moyen.

AIR for iOS

Les étapes ci-dessous décrivent une procédure de développement typique d’une application AIR for iOS :

• Installez iTunes.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

• Générez les ID et fichiers de développement requis sur le portail iOS Provisioning Portal d’Apple, à savoir :

• Certificat de développement

• ID d’application

• Profil de configuration

Vous devez recenser l’ID de tous les périphériques de test sur lesquels vous envisagez d’installer l’application lors de la création du profil de configuration.

• Convertissez le certificat de développement et la clé privée en fichier de keystore P12.

• Programmez le code de l’application en ActionScript ou MXML.

• Compilez l’application par le biais d’un compilateur ActionScript ou MXML.

• Créez les icônes et graphiques de l’écran initial de l’application.

• Créez le fichier descripteur de l’application (utilisez l’espace de noms 2.6 ou ultérieur).

• Mettez en package le fichier IPA à l’aide de l’outil ADT.

• Placez le profil de configuration sur le périphérique de test via iTunes.

• Installez et testez l’application sur le périphérique iOS. Vous pouvez installer le fichier IPA avec iTunes ou l’outil

ADT via USB (prise en charge d’USB sur AIR 3.4 et les versions ultérieures).

Une fois l’application AIR terminée, vous pouvez la mettre à nouveau en package avec un certificat de distribution et un profil de configuration. Vous pouvez alors l’envoyer à l’App Store d’Apple.

Définition des propriétés d’une application mobile

A l’instar des autres applications AIR, vous définissez les propriétés de base d’une application dans le fichier descripteur correspondant. Les applications mobiles ignorent certaines propriétés propres au bureau, telles que la transparence et la taille des fenêtres. Elles peuvent également utiliser les propriétés propres à leur plate-forme. Vous pouvez, par exemple, inclure un élément applications iOS.

Paramètres standard

Divers paramètres de descripteur d’application jouent un rôle important dans toutes les applications pour périphériques mobiles.

Version du moteur d’exécution d’AIR requise

Indiquez la version du moteur d’exécution d’AIR requise par l’application à l’aide de l’espace de noms du fichier descripteur de l’application.

Assigné dans l’élément l’application. Si, par exemple, l’application utilise l’espace de noms AIR 2.7 et que l’utilisateur a installé une version ultérieure, elle continue à assimiler le comportement d’AIR à celui de la version 2.7, même si celui-ci a été modifié dans la version ultérieure. Pour que l’application accède au nouveau comportement et aux nouvelles fonctionnalités, vous devez au préalable modifier l’espace de noms et publier une mise à jour. Les correctifs de sécurité constituent une exception notable à la règle.

application, l’espace de noms détermine globalement les fonctionnalités dont dispose

android pour les applications Android et un élément iPhone pour les

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Sur les périphériques qui utilisent un moteur d’exécution distinct de l’application, tel Android sur AIR 3.6 et versions antérieures, l’utilisateur est invité à installer ou mettre à niveau AIR s’il ne dispose pas de la version requise. Sur les périphériques qui intègrent le moteur d’exécution, tel iPhone, ce cas de figure ne se produit pas, étant donné que la version requise est mise en package avec l’application.

Remarque : (AIR 3.7 et versions ultérieures) Par défaut, ADT compresse le moteur d’exécution pour les applications Android.

Spécifiez l’espace de noms à l’aide de l’attribut xmlns de l’élément racine

application. Les espaces de noms suivants

sont adaptés aux applications mobiles (selon la plate-forme mobile ciblée) :

iOS 4+ and iPhone 3Gs+ or Android: <application xmlns="http://ns.adobe.com/air/application/2.7"> iOS only: <application xmlns="http://ns.adobe.com/air/application/2.0">

Remarque : la prise en charge des périphériques iOS 3 est assurée par le kit SDK de Packager for iPhone, basé sur le kit SDK d’AIR 2.0. Pour plus d’informations sur la création d’applications AIR pour iOS 3, voir Création d’applications

iPhone. Le kit SDK d’AIR 2.6 (et versions ultérieures) prend en charge iOS 4 et les versions ultérieures sur les dispositifs

iPhone 3G, iPhone 4 et iPad.

Voir aussi

« application » à la page 220

Identité d’une application

Plusieurs paramètres devraient être propres à chaque application publiée, à savoir l’ID, le nom et le nom de fichier.

ID d’une application Android

Sous Android, l’ID est converti en nom de package AIR en ajoutant le préfixe « air » à l’ID AIR. Par conséquent, si l’AID AIR est com.exemple.MonApp, le nom du package Android correspond à air.com.exemple.MonApp.

<id>com.example.MyApp</id> <name>My Application</name> <filename>MyApplication</filename>

En outre, si l’ID n’est pas un nom de package géré par le système d’exploitation Android, il est converti en nom valide. Les tirets sont remplacés par des traits de soulignement et les chiffres de début de tout composant ID sont précédés d’un « A » majuscule. Exemple : l’ID 3-goats.1-boat est converti comme suit : air.A3_goats.A1_boat.

Remarque : le préfixe ajouté à l’ID d’application permet d’identifier les applications AIR dans Android Market. Si vous ne souhaitez pas que l’application soit identifiée comme une application AIR en raison du préfixe, vous devez extraire du package le fichier APK, modifier l’ID de l’application, puis remettre celle-ci en package comme indiqué dans Opt-out of

AIR application analytics for Android (disponible en anglais uniquement).

ID d’une application iOS

Définissez l’ID de l’application AIR sur l’ID d’application créée dans le portail iOS Provisioning Portal d’Apple.

Les ID d’application iOS contiennent un identifiant d’application (préfixe), suivi d’un identifiant d’application (suffixe). L’identifiant d’application (préfixe) est une chaîne de caractères, telle que 5RM86Z4DJM, affectée par Apple à l’ID d’application. L’identifiant d’application (suffixe) contient un nom de type domaine inversé que vous sélectionnez. Il se termine parfois par un astérisque (*), qui représente un ID d’application à caractère générique. S’il se termine par un caractère générique, vous pouvez remplacer ce dernier par toute chaîne valide.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Exemple :

• Si l’ID de l’application Apple est 5RM86Z4DJM.com.example.helloWorld, vous devez utiliser

com.example.helloWorld dans le descripteur d’application.

• Si l’ID d’application Apple est 96LPVWEASL.com.example.* (ID d’application à caractère générique), vous

pourriez utiliser

com.example.

com.example.helloWorld, com.example.anotherApp ou tout autre ID qui commence par

• Enfin, si l’ID de l’application Apple ne contient qu’un identifiant d’application (préfixe) et un caractère générique,

tel que :

38JE93KJL.*, vous pouvez utiliser tout ID d’application dans AIR.

Lorsque vous spécifiez l’ID de l’application, ignorez la partie identifiant d’application (préfixe) de l’ID d’application.

Voir aussi

« id » à la page 235

« filename » à la page 231

« name » à la page 243

Version d’une application

Dans AIR 2.5 et ultérieur, spécifiez la version de l’application dans l’élément versionNumber. L’élément version est à présent obsolète. Si vous définissez une valeur dans nombres au plus, séparés par un point (« 0.1.2 », par exemple). Chaque segment du numéro de la version se compose de trois chiffres au plus. (En d’autres termes, la version la plus longue autorisée correspond à « 999.999.999 ».) Vous ne devez pas obligatoirement inclure trois segments dans le nombre. Les numéros de version « 1 » et « 1.0 » sont également valides.

versionNumber, vous devez utiliser une séquence de trois

Vous pouvez aussi définir le libellé de la version à l’aide de l’élément

versionLabel. Si vous ajoutez un libellé de

version, il remplace le numéro de version dans l’écran d’information de l’application Android, par exemple. Vous devez stipuler un libellé de version si une application est distribuée via Android Market. Si vous ne spécifiez pas de

versionLabel dans le descripteur de l’application AIR, la valeur versionNumber est affectée au champ du

valeur libellé de version Android.

<versionNumber>1.23.7<versionNumber> <versionLabel>1.23 Beta 7</versionLabel>

Sous Android, l’élément versionNumber AIR est converti en entier Android versionCode à l’aide de la formule :

a*1000000 + b*1000 + c, où a, b et c correspondent aux composants du numéro de version AIR : a.b.c.

Voir aussi

« version » à la page 251

« versionLabel » à la page 251

« versionNumber » à la page 252

Fichier SWF principal d’une application

Spécifiez le fichier SWF principal de l’application dans l’élément enfant content de l’élément initalWindow. Si vous ciblez des périphériques associés au profil mobile, vous devez utiliser un fichier SWF (les applications de type HTML n’étant pas prises en charge).

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

<content>MyApplication.swf</content>

</initialWindow>

Propriétés de l’écran principal

Plusieurs éléments enfants de l’élément initialWindow contrôlent le comportement et l’aspect initiaux du principal écran de l’application.

• aspectRatio : indique si l’application doit initialement s’afficher au format portrait (hauteur supérieure à la

largeur), au format landscape (hauteur inférieure à la largeur) ou au format any (la scène s’oriente automatiquement dans toutes les orientations).

<aspectRatio>landscape</aspectRatio>

• autoOrients : indique si la scène doit changer automatiquement d’orientation lorsque l’utilisateur fait pivoter le

périphérique ou effectue un autre geste d’orientation tel que l’ouverture ou la fermeture d’un clavier coulissant. Si cet élément est défini sur false (valeur par défaut), la scène ne change pas d’orientation en conjonction avec le périphérique.

• depthAndStencil : indique s’il est nécessaire d’utiliser le tampon de profondeur ou le tampon de modèle. Ces

tampons s’utilisent normalement avec du contenu 3D.

• fullScreen : indique si l’application doit occuper la totalité de l’écran du périphérique ou le partager avec le chrome

standard du système d’exploitation, tel qu’une barre d’état système.

• renderMode : indique si le moteur d’exécution doit effectuer le rendu de l’application via le processeur graphique

(GPU) ou l’unité centrale principale (UC). En règle générale, le rendu sur GPU augmente la vitesse de rendu, mais diverses fonctionnalités, telles que certains modes de fusion et filtres PixelBender, ne sont pas disponibles en mode GPU. Par ailleurs, les fonctionnalités et restrictions du processeur graphique varient selon le périphérique et le pilote de périphérique. Veillez à tester l’application sur un éventail aussi large que possible de périphériques, en particulier en mode GPU.

Vous pouvez définir le mode de rendu sur gpu, cpu, direct ou auto. La valeur par défaut est auto, qui active actuellement le mode UC.

http://gaming.adobe.com/getstarted/.

<renderMode>direct</renderMode>

Remarque : vous ne pouvez pas utiliser renderMode=”direct” pour les applications qui s’exécutent en arrière-plan.

Le mode de rendu sur GPU est soumis aux restrictions suivantes :

• La structure d’application de Flex ne prend pas en charge le mode de rendu sur GPU.

• Les filtres ne sont pas pris en charge.

• Les remplissages et fusions PixelBender ne sont pas pris en charge.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

• Les modes de fusion suivants ne sont pas pris en charge : Calque, Alpha, Effacement, Superposition, Lumière

crue, Eclaircir et Obscurcir.

• Il n’est pas recommandé d’activer le mode de rendu sur GPU dans une application qui lit la vidéo.

• En mode de rendu sur GPU, les champs de texte ne sont pas correctement déplacés vers un emplacement visible

lors de l’ouverture du clavier virtuel. Pour assurer la visibilité du champ de texte lorsque l’utilisateur saisit du texte, déplacez-le vers la zone visible par le biais de la propriété softKeyboardRect de la scène et des événements de clavier logiciel.

• S’il est impossible d’effectuer le rendu d’un objet d’affichage sur le GPU, il n’est pas affiché du tout. Ainsi, si un

filtre est appliqué à un objet d’affichage, ce dernier n’est pas affiché.

Remarque : l’implémentation GPU pour iOS dans AIR 2.6 et les versions ultérieure est très différente de l’implémentation utilisée dans la version précédente, AIR 2.0. Des considérations d’optimisation différentes sont prises en compte.

Voir aussi

« aspectRatio » à la page 223

« autoOrients » à la page 224

« depthAndStencil » à la page 227

« fullScreen » à la page 233

« renderMode » à la page 245

Profils pris en charge

Vous pouvez ajouter l’élément supportedProfiles pour stipuler les profils de périphérique pris en charge par l’application. Réservez le profil mobileDevice aux périphériques mobiles. Lorsque vous exécutez l’application avec l’application de débogage du lanceur AIR (ADL), celle-ci active le premier profil de la liste. Vous disposez également de l’indicateur profils pris en charge. Si l’application s’exécute sous tous les profils, vous pouvez omettre complètement l’élément

supportedProfiles. Dans ce cas de figure, le profil actif par défaut de l’application ADL correspond au profil de

bureau.

Pour spécifier que l’application prend en charge le profil de périphérique mobile et le profil de bureau et que vous souhaitez normalement tester l’application avec le profil mobile, ajoutez l’élément suivant :

<supportedProfiles>mobileDevice desktop</supportedProfiles>

Voir aussi

« supportedProfiles » à la page 248

« Profils de périphérique » à la page 255

« Application de débogage du lanceur AIR (ADL) » à la page 167

-profile lorsque vous exécutez l’application ADL pour sélectionner un profil donné dans la liste de

Extensions natives requises

Les applications qui prennent en charge le profil mobileDevice peuvent recourir aux extensions natives.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

<extensions> <extensionID> com.example.extendedFeature</extensionID>

<extensionID> com.example.anotherFeature</extensionID>

</extensions>

Comportement du clavier virtuel

Définissez l’élément softKeyboardBehavior sur none pour désactiver le comportement d’exécution d’un panoramique et de redimensionnement automatique utilisé par le moteur d’exécution pour s’assurer que le champ de texte de saisie correspondant à la cible d’action est visible après l’affichage du clavier virtuel. Si vous désactivez le comportement automatique, il incombe à l’application de s’assurer que la zone de texte de saisie ou tout autre contenu approprié est visible une fois le clavier affiché. Vous pouvez utiliser la propriété conjonction avec l’élément SoftKeyboardEvent pour détecter l’ouverture du clavier et déterminer la zone masquée par ce dernier.

softKeyboardRect de la scène en

Pour activer le comportement automatique, définissez la valeur de l’élément sur

pan :

Etant donné que pan est la valeur par défaut, omettre l’élément softKeyboardBehavior active également le comportement automatique du clavier.

Remarque : si le mode de rendu sur GPU est également activé, le comportement d’exécution du panoramique n’est pas pris en charge.

Voir aussi

« softKeyboardBehavior » à la page 247

Stage.softKeyboardRect

SoftKeyboardEvent

Paramètres Android

Sur la plate-forme Android, vous disposez de l’élément android du descripteur d’application pour ajouter des informations au manifeste d’application Android (fichier de propriétés d’application utilisé par le système d’exploitation Android). L’outil ADT génère automatiquement le fichier Manifest.xml Android lorsque vous créez le package APK. AIR définit quelques propriétés sur les valeurs requises pour assurer le fonctionnement de diverses fonctionnalités. Toute autre propriété définie dans la section android du descripteur d’application AIR est ajoutée à la section correspondante du fichier Manifest.xml.

Remarque : pour la plupart des applications AIR, vous devez définir les autorisations Android requises par l’application dans l’élément

android, mais il est généralement inutile de définir d’autres propriétés.

Vous ne pouvez définir que les attributs qui gèrent les valeurs de type chaîne, entier ou booléen. La définition de références sur des ressources du package d’application n’est pas prise en charge.

Remarque : le moteur d’exécution nécessite l’installation d’une version du kit SDK ultérieure à la version 9. Vous devez vous assurer que le fichier manifeste inclut

<uses-sdk android:minSdkVersion="9"></uses-sdk>.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Paramètres réservés du manifeste Android

AIR définit plusieurs entrées manifeste dans le document manifeste Android généré pour s’assurer que les fonctionnalités de l’application et du moteur d’exécution fonctionnent correctement. Il est impossible de définir les paramètres suivants :

Elément manifest

Il est impossible de définir les attributs suivants de l’élément manifest :

• package

• android:versionCode

• android:versionName

• xmlns:android

Elément activity

Il est impossible de définir les attributs suivants de l’élément activity principal :

• android:label

• android:icon

Elément application

Il est impossible de définir les attributs suivants de l’élément application :

• android:theme

• android:name

• android:label

• android:windowSoftInputMode

• android:configChanges

• android:screenOrientation

• android:launchMode

Autorisations Android

Le modèle de sécurité Android requiert que chaque application demande l’autorisation d’utiliser les fonctionnalités dotées d’implications d’ordre sécuritaire ou confidentiel. Vous spécifiez ces autorisations lors de la mise en package de l’application et il est impossible de les modifier à l’exécution. Le système d’exploitation Android avertit l’utilisateur des autorisations demandées par une application lors de l’installation de cette dernière. Si l’application ne demande pas une autorisation associée à une fonctionnalité, le système d’exploitation risque de renvoyer une exception lorsque l’application accède à la fonctionnalité. Le renvoi de l’exception n’est toutefois pas garanti. Le moteur d’exécution transmet les exceptions à l’application. En cas d’échec silencieux, un message d’échec de l’autorisation est inséré dans le journal système d’Android.

Dans AIR, vous spécifiez les autorisations Android dans l’élément d’autorisations fait appel au format suivant (PERMISSION_NAME correspondant au nom d’une autorisation Android) :

android du descripteur d’application. L’ajout

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

<![CDATA[

<uses-permission android:name="android.permission.PERMISSION_NAME" />

</manifest>

]]>

</manifestAdditions>

</android>

Les instructions uses-permissions intégrées à l’élément manifest sont directement ajoutées au document manifeste Android.

Les autorisations suivantes sont obligatoires pour utiliser diverses fonctionnalités AIR :

ACCESS_COARSE_LOCATION Permet à l’application d’accéder aux données de localisation du réseau Wi-Fi ou

cellulaire via la classe Geolocation.

ACCESS_FINE_LOCATION Permet à l’application d’accéder aux données GPS via la classe Geolocation.

ACCESS_NETWORK_STATE et ACCESS_WIFI_STATE Permet à l’application d’accéder aux informations du réseau via la

classe NetworkInfo.

CAMERA Permet à l’application d’accéder à la caméra.

Remarque : lorsque vous demandez l’autorisation d’utiliser la fonctionnalité caméra, Android part du principe que l’application requiert également la caméra. Si la caméra est une fonctionnalité facultative de l’application, ajoutez un élément

uses-feature relatif à la caméra au manifeste en définissant l’attribut requis sur false. Voir « Filtrage de la

compatibilité Android » à la page 83.

INTERNET Permet à l’application d’effectuer des requêtes réseau. Permet également de procéder au débogage à

distance.

READ_PHONE_STATE Permet au moteur d’exécution d’AIR de couper le son lors d’appels téléphoniques. Définissez

cette autorisation si l’application lit l’audio lorsqu’elle s’exécute en arrière-plan.

RECORD_AUDIO Permet à l’application d’accéder au microphone.

WAKE_LOCK et DISABLE_KEYGUARD Permet à l’application d’empêcher le périphérique d’entrer en mode de veille à

l’aide des paramètres de la classe SystemIdleMode.

WRITE_EXTERNAL_STORAGE Permet à l’application d’écrire sur la carte mémoire externe du périphérique.

Ainsi, si une application nécessite toutes les autorisations, vous pourriez ajouter l’élément suivant au descripteur de l’application pour les définir :

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

<![CDATA[

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" /> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> <uses-permission android:name="android.permission.CAMERA" /> <uses-permission android:name="android.permission.DISABLE_KEYGUARD" /> <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.READ_PHONE_STATE" /> <uses-permission android:name="android.permission.RECORD_AUDIO" /> <uses-permission android:name="android.permission.WAKE_LOCK" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

</manifest>

]]>

</manifestAdditions>

</android>

Voir aussi

Android Security and Permissions (disponible en anglais uniquement)

Android Manifest.permission class (disponible en anglais uniquement)

Modèles personnalisés d’URI Android

Vous pouvez utiliser un modèle URI personnalisé pour lancer une application AIR à partir d’une page Web ou une application Android native. Etant donné que la prise en charge des URI personnalisés repose sur des filtres d’intention spécifiés dans le manifeste Android, il est impossible d’utiliser cette technique sur d’autres plates-formes.

Pour utiliser un URI personnalisé, ajoutez un élément intent-filter au descripteur d’application dans le bloc

<android>. Les deux éléments intent-filter de l’exemple suivant sont obligatoires. Modifiez l’instruction <data android:scheme="my-customuri"/> en fonction de la chaîne URI associée au modèle personnalisé.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

<![CDATA[

<intent-filter>

</activity>

</application>

</manifest>

]]>

</manifestAdditions>

</android>

Un filtre d’intention avertit le système d’exploitation Android que l’application est en mesure d’exécuter une action donnée. Dans le cas d’un URI personnalisé, cela signifie que l’utilisateur a cliqué sur un lien basé sur ce modèle d’URI (et le navigateur ne sait pas comment le gérer).

Si l’application est appelée par le biais d’un URI personnalisé, l’objet NativeApplication distribue un événement

invoke. L’URL du lien, paramètres d’interrogation inclus, est placée dans le tableau arguments de l’objet

InvokeEvent. Vous disposez d’un nombre illimité d’éléments intent-filter.

Remarque : les liens dans une occurrence de StageWebView ne peuvent pas ouvrir les URL qui font appel à un modèle d’URI personnalisé.

Voir aussi

Android intent filters (disponible en anglais uniquement)

Android actions and categories (disponible en anglais uniquement)

Filtrage de la compatibilité Android

Le système d’exploitation Android utilise divers éléments du fichier manifeste de l’application pour déterminer si celle-ci est compatible avec un périphérique donné. L’ajout de ces informations au fichier manifeste est facultatif. Si vous n’incluez pas ces éléments, l’application peut être installée sur tout périphérique Android. Elle risque toutefois de ne fonctionner correctement sur aucun périphérique Android. Une application pour caméra s’avère par exemple d’une utilité limitée sur un téléphone qui n’est pas équipé de caméra.

Vous disposez des balises de manifeste Android suivantes à des fins de filtrage :

• supports-screens

• uses-configuration

• uses-feature

• uses-sdk (dans AIR 3+)

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Applications pour caméra

Si vous demandez l’autorisation caméra pour l’application, Android part du principe que l’application nécessite toutes les fonctionnalités de caméra disponibles, y compris la mise au point automatique et le flash. Si l’application ne requiert pas toutes les fonctionnalités de caméra ou si la caméra est une fonctionnalité facultative, définissez les divers éléments

uses-feature associés à la caméra pour indiquer qu’ils sont facultatifs. Les utilisateurs dont le périphérique ne gère

pas une fonctionnalité ou n’est pas équipé de caméra ne pourront sinon pas trouver l’application dans Android Market.

L’exemple suivant illustre la procédure de demande de l’autorisation caméra et indique comment rendre toutes les fonctionnalités de la caméra facultatives :

<![CDATA[

<uses-permission android:name="android.permission.CAMERA" /> <uses-feature android:name="android.hardware.camera"

android:required="false"/>

<uses-feature android:name="android.hardware.camera.autofocus"

android:required="false"/>

<uses-feature android:name="android.hardware.camera.flash"

android:required="false"/>

</manifest>

]]>

</manifestAdditions>

</android>

Applications d’enregistrement de l’audio

Si vous demandez l’autorisation d’enregistrer l’audio, Android considère comme acquis que l’application nécessite un microphone. Si l’enregistrement de l’audio est une fonctionnalité facultative de l’application, vous disposez d’une balise uses-feature pour spécifier que le microphone est inutile. Les utilisateurs dont le périphérique n’est pas équipé d’un microphone ne pourront sinon pas trouver l’application sur Android Market.

L’exemple suivant illustre la procédure de demande d’une autorisation d’utilisation du microphone, le matériel associé restant facultatif :

<![CDATA[

<uses-permission android:name="android.permission.RECORD_AUDIO" /> <uses-feature android:name="android.hardware.microphone"

android:required="false"/>

</manifest>

]]>

</manifestAdditions>

</android>

Bouton de menu dans Android 3

Dans Android 3 (qui s’exécute sur les tablettes), les applications doivent normalement fournir leur propre bouton pour ouvrir un menu d’options. Le kit SDK d’Android dispose désormais d’un composant ActionBar qui affiche un bouton de menu. Le bouton de menu qu’affiche le système d’exploitation dans la partie inférieure de l’écran de la tablette (en regard des boutons Retour, Accueil et Apps récentes) n’apparaît plus dans les applications qui ciblent le kit SDK d’Android niveau 11+.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Voir aussi

Android Developers : Android Compatibility (disponible en anglais uniquement)

Android Developers : Android feature name constants (disponible en anglais uniquement)

Emplacement d’installation

Vous pouvez autoriser l’installation ou le transfert de l’application sur la carte mémoire externe en définissant l’attribut

installLocation de l’élément Android manifest sur auto ou preferExternal :

<![CDATA[

]]>

</manifestAdditions>

</android>

Le système d’exploitation Android ne garantit pas que l’application soit installée sur la carte mémoire externe. Un utilisateur peut également transférer une application entre la mémoire interne et la mémoire externe par le biais de l’application Réglages du système.

Même si l’application est installée sur la carte mémoire externe, le cache d’application, les données utilisateur telles que le contenu du répertoire app-storage, les objets partagés et les fichiers temporaires continuent à être stockés en mémoire interne. Pour éviter de solliciter trop de mémoire interne, sélectionnez avec discernement les données enregistrées dans le répertoire de stockage de l’application. Enregistrez les volumes élevés de données sur la carte SD (emplacements carte SD sous Android).

File.userDirectory ou File.documentsDirectory, qui pointent tous deux vers la racine de la

Activation de Flash Player et d’autres modules d’extension dans un objet StageWebView

Dans Android 3.0 et les versions ultérieures, l’application doit activer l’accélération matérielle dans l’élément de l’application Android pour afficher le contenu des modules d’extension dans un objet StageWebView. Pour activer le rendu sur le module d’extension, définissez l’attribut

true :

<![CDATA[

</manifest>

]]>

</manifestAdditions>

</android>

AIR valide les éléments et les attributs inclus dans la portion Android du fichier descripteur d’application. Par défaut, AIR effectue la validation au moyen du kit SDK d’Android 2.3. Etant donné que l’attribut

android:hardwareAccelerated a été ajouté dans Android 3.0, vous devez configurer l’outil ADT d’AIR de façon à

effectuer la validation au moyen du kit SDK d’Android 3.0 (ou version ultérieure).

Pour cela, téléchargez tout d’abord le kit SDK d’Android 3 : Android Developers: Installing the SDK . Lors de la mise en package, définissez l’option

-platformsdk sur le chemin contenant le kit SDK Android approprié (définissez le

chemin sur le répertoire contenant le dossier outils d’Android). Exemple :

android:hardwareAccelerated de l’élément application sur

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

adt -package

-target apk

-storetype pkcs12 -keystore cert.p12 -storepass foo myApp.apk myApp-app.xml

-platformsdk c:\androidSDK myApp.swf other.files

Vous pouvez également définir la variable d’environnement AIR_ANDROID_SDK_HOME sur le chemin contenant le kit SDK d’Android. Etant donné que Flash Builder et Flash Professional ne permettent pas d’ajouter d’autres paramètres lors de la mise en package, la définition de cette variable d’environnement permet de recourir aux paramètres du kit SDK d’Android qui n’étaient pas disponibles lors de la publication du kit SDK d’AIR que vous utilisez actuellement. Voir « Variables d’environnement ADT » à la page 196.

Codage des couleurs

AIR 3+

Dans AIR 3 et les versions ultérieures, le moteur d’exécution configure l’écran de façon à ce qu’il effectue le rendu des couleurs 32 bits. Dans les versions antérieures d’AIR, le moteur d’exécution utilise les couleurs 16 bits. Vous pouvez demander au moteur d’exécution d’utiliser les couleurs 16 bits à l’aide de l’élément <colorDepth> du descripteur d’application :

</android>

L’utilisation de la profondeur de couleurs 16 bits peut augmenter les performances de rendu, au détriment de la fidélité des couleurs.

Paramètres iOS

Les paramètres réservés aux périphériques iOS sont placés dans l’élément <iPhone> du descripteur de l’application. L’élément

Entitlements, un élément externalSwfs et un élément forceCPURenderModeForDevices comme enfants.

L’élément à l’application. Les valeurs suivantes déterminent, par exemple, le style de la barre d’état de l’application et stipulent que cette dernière ne nécessite pas un accès Wi-Fi permanent.

</InfoAdditions>

iPhone peut avoir un élément InfoAdditions, un élément requestedDisplayResolution, un élément

InfoAdditions permet de spécifier des paires clé-valeur ajoutées au fichier de paramètres Info.plist associé

<![CDATA[

<key>UIStatusBarStyle</key> <string>UIStatusBarStyleBlackOpaque</string> <key>UIRequiresPersistentWiFi</key> <string>NO</string>

]]>

Les paramètres InfoAdditions sont entourés d’une balise CDATA.

L’élément

Entitlements permet de spécifier les paires clé-valeur ajoutées au fichier de paramètres Entitlements.plist

de l’application. Les paramètres Entitlements.plist permettent à certaines fonctions d’iOS, notamment aux notifications Push, d’accéder à l’application.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Pour plus d’informations sur les paramètres Info.plist et Entitlements.plist, voir la documentation Apple destinée aux développeurs.

Prise en charge de tâches en arrière-plan sous iOS

AIR 3.3

Adobe AIR 3.3 et les versions ultérieures prennent en charge les multitâches sous iOS en permettant certains comportements en arrière-plan :

• Audio

• Mises à jour de l’emplacement

• Mise en réseau

• Annulation de l’exécution d’une application en arrière-plan

Remarque : avec les versions 21 et antérieures de SWF, AIR ne prend pas en charge l’exécution en arrière-plan sur iOS et Android lorsque le mode de rendu est défini sur direct. En raison de cette restriction, les applications basées sur Stage3D ne peuvent pas exécuter des tâches en arrière-plan telles que la lecture de l’audio, les mises à jour d’emplacement, les téléchargements vers/depuis le réseau, etc. iOS n’autorise pas les appels OpenGLES/de rendu en arrière-plan. Il interrompt ainsi les applications qui tentent de lancer des appels en arrière-plan. Android ne restreint pas les appels OpenGLES ou toute autre tâche en arrière-plan lancée par les applications (telle que la lecture d’audio). Avec les versions 22 et ultérieures de SWF, les applications mobiles AIR peuvent s’exécuter en arrière-plan lorsque renderMode est définir sur direct. Le moteur d’exécution AIR iOS entraîne une erreur ActionScript (3768 - L’API Stage3D ne peut pas être utilisée lors d’une exécution en arrière-plan) si les appels OpenGLES sont effectués en arrière-plan. Cependant, aucune erreur ne se produit sur Android car ses applications natives sont autorisées à effectuer des appels OpenGLES en arrière-plan. Pour une utilisation optimale des ressources mobiles, n’effectuez pas d’appels de rendu lorsqu’une application s’exécute en arrière-plan.

Son en arrière-plan

Pour activer la lecture et l’enregistrement audio en arrière-plan, incluez la paire clé-valeur suivante à l’élément

InfoAdditions :

<![CDATA[ <key>UIBackgroundModes</key>

<array>

<string>audio</string> </array>

]]>

</InfoAdditions>

Mises à jour de l’emplacement en arrière-plan

Pour activer les mises à jour de l’emplacement en arrière-plan, incluez la paire clé-valeur suivante à l’élément

InfoAdditions :

<![CDATA[

<key>UIBackgroundModes</key> <array>

<string>location</string> </array> ]]>

</InfoAdditions>

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Remarque : utilisez cette fonction uniquement lorsque cela est nécessaire, car les API d’emplacement consomment énormément de batterie.

Mise en réseau en arrière-plan

Pour exécuter de brèves tâches en arrière-plan, votre application définit la propriété

NativeApplication.nativeApplication.executeInBackground sur true.

Par exemple, votre application peut lancer une opération de mise à jour d’un fichier après que l’utilisateur place au premier plan une autre application. Lorsque l’application reçoit un événement de fin de téléchargement, elle peut

NativeApplication.nativeApplication.executeInBackground sur false.

définir

Définir la propriété

NativeApplication.nativeApplication.executeInBackground sur true ne garantit pas

l’exécution indéfinie de l’application, car iOS impose une limite temporelle aux tâches en arrière-plan. Lorsque iOS arrête le traitement en arrière-plan, AIR distribue un événement

NativeApplication.suspend.

Annulation de l’exécution en arrière-plan

Votre application peut annuler explicitement l’exécution en arrière-plan en incluant la paire clé-valeur suivante à l’élément

</InfoAdditions>

InfoAdditions :

<![CDATA[ <key>UIApplicationExitsOnSuspend</key> <true/> ]]>

Paramètres InfoAdditions iOS réservés

AIR définit plusieurs entrées dans le fichier Info.plist généré pour s’assurer que les fonctionnalités de l’application et du moteur d’exécution fonctionnent correctement. Il est impossible de définir les paramètres suivants :

CFBundleDisplayName

CFBundleExecutable

CFBundleIconFiles

CFBundleIdentifier

CFBundleInfoDictionaryVersion

CFBundlePackageType

CFBundleResourceSpecification

CFBundleShortVersionString

CFBundleSupportedPlatforms

CFBundleVersion

CTAutoOrients

CTInitialWindowTitle

CTInitialWindowVisible

CTIosSdkVersion

CTMaxSWFMajorVersion

DTPlatformName

DTSDKName

MinimumOSVersion (applicable dans AIR 3.3 et les versions ultérieures)

NSMainNibFile

UIInterfaceOrientation

UIStatusBarHidden

UISupportedInterfaceOrientations

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Prise en charge de différents modèles de périphérique iOS

Pour prendre en charge l’iPad, incluez les paramètres clé-valeur appropriés de UIDeviceFamily dans l’élément

InfoAdditions. Le paramètre UIDeviceFamily est un tableau de chaînes. Chaque chaîne définit les périphériques

pris en charge. Le paramètre paramètre

<string>2</string> définit la prise en charge de l’iPad. Si vous spécifiez uniquement l’un de ces

paramètres, seule cette famille de périphériques est prise en charge. Par exemple, le paramètre suivant limite la prise en charge à l’iPad :

<key>UIDeviceFamily</key>

<array>

</array>>

Le paramètre suivant prend en charge les deux familles de périphériques (iPhone/iPod Touch et iPad) :

<key>UIDeviceFamily</key> <array>

</array>

En outre, dans AIR 3.7 et les versions ultérieures, vous pouvez utiliser la balise forceCPURenderModeForDevices balise pour forcer le mode de rendu UC pour un ensemble de périphériques spécifiés et activer le mode de rendu GPU les périphériques iOS restants.

<string>1</string> définit la prise en charge de l’iPhone et de l’iPod touch. Le

Vous ajoutez cette balise comme enfant de la balise

iPhone et spécifiez une liste de noms de modèles séparés par des

espaces. Pour obtenir une liste de noms de modèle valides, reportez-vous à « forceCPURenderModeForDevices » à la page 233.

Par exemple, pour utiliser le mode UC dans les anciens iPods, iPhones et iPads, et activer le mode GPU pour tous les autres périphériques, spécifiez ce qui suit dans le descripteur d’application :

... <renderMode>GPU</renderMode> ... <iPhone> ... <forceCPURenderModeForDevices>iPad1,1 iPhone1,1 iPhone1,2 iPod1,1 </forceCPURenderModeForDevices> </iPhone>

Affichages à haute résolution

L’élément requestedDisplayResolution indique si l’application doit utiliser le mode de résolution standard ou high sur les périphériques iOS équipés d’un écran à haute résolution.

Le mode Haute résolution permet d’adresser individuellement chaque pixel d’un écran à haute résolution. En mode Standard, l’écran du périphérique est assimilé par l’application à un écran à résolution standard. Dessiner un pixel unique en ce mode définit la couleur de quatre pixels sur un écran à haute résolution.

Le paramètre par défaut est

requestedDisplayResolution en tant qu’enfant de l’élément iPhone (et non de l’élément InfoAdditions ou initialWindow).

standard. Notez que, afin de cibler les périphériques iOS, vous utilisez l’élément

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Si vous voulez utiliser d’autres paramètres sur d’autres périphériques, spécifiez la valeur par défaut comme la valeur de l’élément

requestedDisplayResolution. Utilisez l’attribut excludeDevices afin de spécifier les périphériques

qui doivent utiliser la valeur opposée. Par exemple, avec le code suivant, le mode haute résolution est utilisé sur tous les périphériques qui le prennent en charge, sauf les iPad de 3e génération, qui utilisent le mode standard.

L’attribut excludeDevices est disponible dans AIR 3.6 et ultérieur.

Voir aussi

« requestedDisplayResolution » à la page 246

Renaun Erickson : Developing for both retina and non-retina iOS screens using AIR 2.6 (disponible en anglais uniquement)

Modèles d’URI personnalisés iOS

L’enregistrement d’un modèle d’URI personnalisé permet d’appeler l’application à l’aide d’un lien inséré dans une page Web ou d’une autre application native installée sur le périphérique. Pour enregistrer un modèle d’URI, ajoutez une clé CFBundleURLTypes à l’élément InfoAdditions. L’exemple suivant enregistre un modèle d’URI, com.example.app, afin de permettre l’appel d’une application par le biais d’URL de type : example://foo.

<key>CFBundleURLTypes</key> <array>

<dict>

<key>CFBundleURLSchemes</key> <array>

<string>example</string>

</array> <key>CFBundleURLName</key> <string>com.example.app</string>

</dict>

</array>

Si l’application est appelée par le biais d’un URI personnalisé, l’objet NativeApplication distribue un événement

invoke. L’URL du lien, paramètres d’interrogation inclus, est placée dans le tableau arguments de l’objet

InvokeEvent. Vous disposez d’un nombre illimité de modèles d’URI.

Remarque : les liens dans une occurrence de StageWebView ne peuvent pas ouvrir les URL qui font appel à un modèle d’URI personnalisé.

Remarque : si une autre application a déjà enregistré un modèle d’URI, il est impossible d’associer votre application au modèle.

Filtrage de la compatibilité iOS

Ajoutez des entrées à un tableau UIRequiredDeviceCapabilities dans l’élément InfoAdditions si l’application doit être réservée aux périphériques dotés de fonctionnalités matérielles ou logicielles déterminées. L’entrée suivante indique, par exemple, qu’une application requiert un appareil photo et un microphone :

<key>UIRequiredDeviceCapabilities</key> <array>

<string>microphone</string> <string>still-camera</string>

</array>

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Si le périphérique n’est pas équipé de ces fonctionnalités, il est impossible d’installer l’application. Les paramètres de fonctionnalités associés aux applications AIR sont les suivants :

telephony

wifi

sms

still-camera

auto-focus-camera

front-facing-camera

camera-flash

video-camera

accelerometer

location-services

gps

microphone

AIR 2.6+ ajoute automatiquement armv7 et opengles-2 à la liste des fonctionnalités requises.

Remarque : il est inutile d’inclure ces fonctionnalités dans le descripteur de l’application pour que cette dernière les utilise. Ne faites appel aux paramètres UIRequiredDeviceCapabilities que pour interdire aux utilisateurs d’installer l’application sur un périphérique sur lequel elle ne peut pas fonctionner correctement.

Fermeture plutôt que mise en pause

Lorsqu’un utilisateur quitte par basculement une application AIR, elle s’exécute en arrière-plan et est mise en pause. Pour que l’application se ferme complètement au lieu d’être mise en pause, définissez la propriété

UIApplicationExitsOnSuspend sur YES :

<key>UIApplicationExitsOnSuspend</key> <true/>

Réduire la taille des téléchargements en chargeant des fichiers SWF externes d’actifs uniquement

AIR 3.7

Vous pouvez réduire la taille de téléchargement initiale de l’application en compressant un sous-ensemble des fichiers SWF utilisées par votre application et en chargeant les fichiers SWF externes restants (actif uniquement) lors de l’exécution à l’aide de la méthode

Loader.load(). Pour utiliser cette fonction, vous devez compresser l’application de

telle sorte qu’ADT déplace tout le pseudo-code ActionScript (ABC) depuis les fichiers SWF chargés en externe vers le fichier SWF principal de l’application, laissant un fichier SWF qui contient uniquement des actifs. Cela est nécessaire pour respecter la règle de l’Apple Store qui interdit le téléchargement tout code une fois qu’une application est installée.

ADT effectue les opérations suivantes pour prendre en charge les fichiers SWF chargés en externe (également appelés fichiers SWF démunis) :

• Lit le fichier texte spécifié dans le sous-élément <externalSwfs> de l’élément <iPhone> pour accéder à la liste de

fichiers SWF séparés par une ligne à charger à la prochaine exécution :

<iPhone> ... <externalSwfs>FilewithPathsOfSWFsThatAreToNotToBePackaged.txt</externalSwfs> </iPhone>

• Transfert le code ABC de chaque fichier SWF chargé en externe vers l’exécutable principal.

• Omet les fichiers SWF chargés en externe du fichier .ipa.

• Copie les fichiers SWF démunis dans le répertoire .remoteStrippedSWFs. Vous hébergez ces fichiers SWF sur un

serveur Web et votre application les charge, au besoin, au moment de l’exécution.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Vous devez indiquer les fichiers SWF à charger au moment de l’exécution en spécifiant leurs noms, un par ligne dans un fichier texte, comme le montre l’exemple suivant :

assets/Level1/Level1.swf assets/Level2/Level2.swf assets/Level3/Level3.swf assets/Level4/Level4.swf

Le chemin d’accès du fichier spécifié est relatif au fichier descripteur de l’application. En outre, vous devez spécifier ces fichiers SWF comme actifs dans la commande

adt.

Remarque : Cette fonction s’applique aux compressions standard uniquement. Pour une compression rapide (par exemple à l’aide d’un interpréteur, d’un simulateur, ou d’un débogueur) ADT ne crée pas de fichiers SWF démunis.

Pour plus d’informations sur cette fonction, y compris un exemple de code, reportez-vous à Hébergement externe

de fichiers SWF secondaires pour applications AIR sur iOS, une publication de blog par Abhinav Dhandh,

ingénieur chez Adobe.

Icônes d’une application

Le tableau suivant indique les tailles d’icônes utilisées sur chaque plate-forme mobile :

Taille d’icône Plate-forme

29x29 iOS

36x36 Android

48x48 Android, iOS

50x50 iOS

57x57 iOS

58x58 iOS

72x72 Android, iOS

96x96 Android

100x100 iOS

114x114 iOS

144x144 Android, iOS

512 x 512 iOS

1 024 x 1024 iOS

Spécifiez le chemin d’accès aux fichiers d’icône dans l’élément icon du fichier descripteur de l’application :

<icon>

<image36x36>assets/icon36.png</image36x36> <image48x48>assets/icon48.png</image48x48> <image72x72>assets/icon72.png</image72x72>

</icon>

Si vous ne fournissez pas d’icône de la taille indiquée, la taille suivante est utilisée et l’image est mise à l’échelle en conséquence.

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Icônes sous Android

Sous Android, les icônes spécifiées dans le descripteur d’application servent d’icône de lancement de l’application. L’icône de lancement de l’application doit être fournie sous la forme d’un ensemble d’images PNG de 36x36, 48x48, 72x72, 96x96 et 144x144 pixels. Ces tailles d’icône correspondent respectivement aux écrans de faible densité, densité moyenne et densité élevée.

Icônes sous iOS

Les icônes définies dans le descripteur d’application sont utilisées comme suit pour une application iOS :

• Icône de 29 par 29 pixels : icône Recherche Spotlight pour les iPhone/iPod de faible résolution et icône Réglages

pour les iPad de faible résolution.

• Icône de 48 par 48 pixels : AIR ajoute une bordure à cette image et l’utilise en tant qu’icône 50x50 pour la recherche

Spotlight sur les iPad de faible résolution.

• Icône de 50 par 50 pixels : recherche Spotlight pour les iPad de faible résolution.

• Icône de 57 par 57 pixels : icône de l’application pour les iPhone/iPod de faible résolution.

• Icône de 58 par 58 pixels : icône Spotlight pour les iPhone/iPod munis d’un écran Retina et icône Réglages pour les

iPad munis d’un écran Retina.

• Icône de 72 par 72 pixels (facultatif) : icône de l’application pour les iPad de faible résolution.

• Icône de 100 par 100 pixels : recherche Spotlight pour les iPad munis d’un écran Retina.

• Icône de 114 par 114 pixels : icône de l’application pour les iPhone/iPod munis d’un écran Retina.

• Icône de 144 par 144 pixels : icône de l’application pour les iPad munis d’un écran Retina.

• Icône de 512 par 512 pixels : icône de l’application pour les iPhone/iPod/iPad de faible résolution. iTunes affiche

cette icône. Le fichier PNG de 512 pixels est réservé au test des versions de développement de l’application. Lorsque vous envoyez l’application définitive à l’App Store d’Apple, vous transmettez séparément l’image de 512 pixels au format JPG. Elle n’est pas incluse dans l’IPA.

• Icône de 1 024 par 1 024 pixels : icône de l’application pour les iPhone/iPod/iPad munis d’un écran Retina.

Etant donné qu’iOS ajoute un effet de lueur jaune à une icône, il est inutile d’appliquer l’effet à l’image source. Pour désactiver cet effet de lueur jaune activé par défaut, ajoutez le texte ci-dessous à l’élément

InfoAdditions du fichier

descripteur d’application :

<![CDATA[

<key>UIPrerenderedIcon</key> <true/>

]]>

</InfoAdditions>

Remarque : sur iOS, les métadonnées de l’application sont insérées en tant que métadonnées png dans les icônes de l’application afin qu’Adobe puisse connaître le nombre d’applications AIR disponibles dans l’App Store iOS d’Apple. Si vous ne souhaitez pas que votre application soit identifiée comme une application AIR, vous devez extraire le fichier IPA du package, retirer les métadonnées de l’icône, puis remettre le fichier IPA en package. Cette procédure est décrite dans l’article Opt-out of AIR application analytics for iOS (disponible en anglais uniquement).

Voir aussi

« icon » à la page 234

« imageNxN » à la page 235

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Android Developers : Icon Design Guidelines (disponible en anglais uniquement)

iOS Human Interface Guidelines: Custom Icon and Image Creation Guidelines (disponible en anglais uniquement)

Images de lancement iOS

Outre les icônes de l’application, vous devez fournir au moins une image de lancement appelée Default.png. Vous pouvez, si vous le souhaitez, inclure des images de lancement distinctes selon l’orientation au démarrage, la résolution (notamment sur les écrans Retina haute résolution et les écrans au format 16:9) et le périphérique. Vous pouvez également inclure différentes images de lancement à utiliser lorsque l’utilisateur appelle l’application par le biais d’une URL.

Les fichiers d’image de lancement ne sont pas référencés dans le descripteur de l’application et doivent résider dans le répertoire racine de cette dernière. (Ne placez pas les fichiers dans un sous-répertoire.)

Modèle d’affectation de noms de fichiers

Attribuez un nom à l’image comme suit :

basename + screen size modifier + urischeme + orientation + scale + device + .png

La partie basename du nom de fichier est l’unique partie requise. Elle correspond soit à Default (avec un D majuscule), soit au nom spécifié à l’aide de la clé l’application.

UILaunchImageFile dans l’élément InfoAdditions du descripteur de

La partie screen size modifier désigne la taille de l’écran lorsqu’elle ne correspond à aucune taille d’écran standard. Ce modificateur s’applique uniquement aux modèles d’iPhone et d’iPod dotés d’écrans 16:9, tels que l’iPhone 5 et l’iPod touch de 5e génération. L’unique valeur prise en charge par ce modificateur est

-568h. Etant donné que ces

périphériques prennent en charge les affichages haute résolution (Retina), le modificateur de taille d’écran est toujours utilisé avec une image possédant également le modificateur d’échelle défaut pour ces périphériques est

Default-568h@2x.png.

@2x. Le nom d’image de lancement complet par

La partie urischeme correspond à la chaîne d’identification du modèle d’URI. Cette partie s’applique uniquement si votre application mobile prend en charge un ou plusieurs modèles d’URL personnalisés. Par exemple, s’il est possible d’appeler l’application par le biais d’un lien tel que

example://foo, faites de -example la partie modèle du nom de

fichier de l’image de lancement.

La partie orientation permet de spécifier plusieurs images de lancement selon l’orientation du périphérique lors du démarrage de l’application. Cette partie s’applique uniquement aux images des applications de l’iPad. Elle peut posséder l’une des valeurs suivantes, selon l’orientation du périphérique lorsque l’application démarre :

• -Portrait

• -PortraitUpsideDown

• -Landscape

• -LandscapeLeft

• -LandscapeRight

La partie scale correspond à

@2x pour les images de lancement réservées aux écrans haute résolution (Retina).

(Omettez complètement la partie scale pour les images associées aux écrans à résolution standard.) Pour les images de lancement des périphériques plus grands, tels que l’iPhone 5 et l’iPod touch de 5e génération, vous devez également spécifier le modificateur de taille d’écran

-528h après la partie basename et avant tout autre partie.

La partie device est utilisée pour désigner les images de lancement des périphériques et des téléphones de poche. Cette partie est utilisée lorsque votre application est une application mobile universelle qui prend en charge les périphériques de poche et les tablettes avec une seule interface binaire-programme. La valeur doit être soit

~ipad soit ~iphone (pour

l’iPhone et l’iPod Touch).

Dernière mise à jour le 14/11/2013

CRÉATION D’APPLICATIONS ADOBE AIR

Développement d’applications AIR pour périphériques mobiles

Pour l’iPhone, vous ne pouvez inclure que les images au format portrait. Utilisez des images de 320 x 480 pixels pour les périphériques de résolution standard, des images de 640 x 960 pixels pour les périphériques haute résolution, et des images 640 x 1 136 pixels pour les périphériques 16:9 tels que l’iPhone 5 et l’iPod touch de 5e génération).

Pour l’iPad, vous pouvez inclure les images suivantes :

• AIR 3.3 et versions antérieures : images qui ne sont pas au mode plein écran : vous pouvez inclure des images au

format paysage (1 024 x 748 en résolution normale, 2 048 x 1 496 en haute résolution) et au format portrait (768 x 1 004 en résolution normale, 1 536 x 2 008 en haute résolution).

• AIR 3.4 et versions ultérieures : images plein écran : vous pouvez inclure des images au format paysage (1 024 x 768

en résolution normale, 2 048 x 1 536 en haute résolution) et au format portrait (768 x 1 024 en résolution normale, 1 536 x 2 048 en haute résolution). Notez que lorsque vous mettez en package une image plein écran pour une application qui n’est pas affichée en plein écran, les 20 pixels supérieurs (les 40 pixels supérieurs pour une image haute résolution) sont masqués par la barre d’état. Evitez d’afficher des informations importantes dans cette zone.

Exemples

Le tableau suivant contient un exemple d’ensemble d’images de lancement que vous pourriez associer à une application hypothétique qui prend en charge l’éventail le plus large possible de périphériques et d’orientations. L’utilisateur peut lancer l’application par le biais d’URL basées sur le modèle

example:// :

Nom du fichier Taille de l’image Utilisation

Default.png 320 x 480 iPhone, résolution standard

Default@2x.png 640x 960 iPhone, résolution élevée

Default-568h@2x.png 640 x 1 136 iPhone, haute résolution, format d’image

Default-Portrait.png 768 x 1 004 (AIR 3.3 et

versions antérieures)

768 x 1 024 (AIR 3.4 et versions ultérieures)

Default-Portrait@2x.png 1 536 x 2 008 (AIR 3.3 et

versions antérieures)

1 536 x 2 048 (AIR 3.4 et versions ultérieures)

Default-PortraitUpsideDown.png 768 x 1 004 (AIR 3.3 et

versions antérieures) 768 x 1 024 (AIR 3.4 et versions ultérieures)

Default-PortraitUpsideDown@2x.png 1 536 x 2 008 (AIR 3.3 et

versions antérieures) 1 536 x 2 048 (AIR 3.4 et versions ultérieures)

Default-Landscape.png 1 024 x 768 iPad, orientation paysage gauche

16:9

iPad, orientation portrait

iPad, haute résolution, orientation portrait

iPad, orientation portrait inversée

iPad, haute résolution, orientation portrait à l’envers

Default-LandscapeLeft@2x.png 2 048 x 1 536 iPad, haute résolution, orientation paysage

Default-LandscapeRight.png 1 024 x 768 iPad, orientation paysage droite

Default-LandscapeRight@2x.png 2 048 x 1 536 iPad, haute résolution, orientation paysage

Default-example.png 320 x 480 example:// URL sur un iPhone standard

vers la gauche

vers la droite

Dernière mise à jour le 14/11/2013

ADOBE Air Création d’applications [fr]

Specifications and Main Features

Frequently Asked Questions

User Manual

Informations juridiques

Sommaire

Chapitre 1 : A propos d’Adobe AIR

Chapitre 2 : Installation d’Adobe AIR

Installation d’Adobe AIR

Désinstallation d’Adobe AIR

Installation et exécution des exemples d’application AIR

Mises à jour d’Adobe Air

Chapitre 3 : Utilisation des API AIR

Classes ActionScript 3.0 propres à AIR

Classes Flash Player contenant des fonctionnalités propres à AIR

Composants Flex propres à AIR

Chapitre 4 : Outils de la plate-forme Adobe Flash pour le développement AIR

Installation du kit de développement SDK AIR

Téléchargement et installation du kit SDK AIR

Contenu du kit SDK AIR

Configuration du kit SDK Flex

Installation du kit SDK Flex

Configuration de kits SDK externes

Chapitre 5 : Création d’une première application AIR

Création d’une première application de bureau AIR Flex dans Flash Builder

Création d’un projet AIR

Ecriture du code de l’application AIR

Test de l’application AIR

Mise en package, signature et exécution de l’application AIR

Création d’une première application de bureau AIR dans Flash Professional

Création de l’application Hello World dans Flash

Test de l’application

Mise en package de l’application

Création d’une première application AIR for Android dans Flash Professional

Création d’une première application AIR for iOS

Création du contenu de l’application

Création des icônes et des graphiques de l’écran initial de l’application

Création du fichier descripteur de l’application

Compilation du fichier IPA

Installation de l’application sur un périphérique

Modification des graphiques de l’écran initial

Création d’une première application AIR de type HTML dans Dreamweaver

Préparation des fichiers de l’application

Création de l’application Adobe AIR

Installation de l’application sur un bureau

Aperçu de l’application Adobe AIR

Création d’une première application AIR de type HTML à l’aide du kit SDK d’AIR

Création des fichiers du projet

Création du fichier descripteur d’application AIR

Création de la page HTML de l’application

Test de l’application

Création du fichier d’installation AIR

Etapes suivantes

Création d’une première application de bureau AIR à l’aide du kit SDK de Flex

Création du fichier descripteur d’application AIR

Programmation du code de l’application

Compilation de l’application

Test de l’application

Création du fichier d’installation AIR

Création d’une première application AIR for Android à l’aide du kit SDK de Flex

Création du fichier descripteur d’application AIR

Programmation du code de l’application

Compilation de l’application

Test de l’application

Création du fichier de package APK

Chapitre 6 : Développement d’applications de bureau AIR

Flux de travail de développement d’une application de bureau AIR

Applications de type SWF

Applications de type HTML

Création de programmes d’installation natifs destinés aux applications AIR

Création d’applications AIR à l’aide d’un paquet de moteur d’exécution captif

Définition des propriétés d’une application de bureau

Version du moteur d’exécution d’AIR requise

Identité d’une application

Version d’une application

Propriétés de la fenêtre principale

Fonctionnalités associées au bureau

Profils pris en charge

Extensions natives requises

Icônes d’une application