ADOBE FLEX User Manual

Développement d'applications mobiles avec

ADOBE® FLEX® et ADOBE® FLASH® BUILDER

Informations juridiques

Pour consulter les informations juridiques, voir http://help.adobe.com/fr_FR/legalnotices/index.html.

Dernière mise à jour le 8/7/2011

Sommaire

Chapitre 1 : Prise en main

Premiers pas avec les applications mobiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Différences entre le développement d’applications mobiles, de bureau et de navigateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Chapitre 2 : Environnement de développement

Création d’une application Android dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

Création d’une application iOS dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Création d’une application BlackBerry Tablet OS dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Création d’un projet mobile ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Définition des préférences de projet mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Connexion des périphériques Google Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

Connexion de périphériques Apple iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

Chapitre 3 : Interface utilisateur et présentation

Présentation d’une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Gestion des saisies de l’utilisateur dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Définition d’une application mobile et d’un écran de démarrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Définition de vues dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Définition d’onglets dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

Définition de contrôles de navigation, de titre et d’action dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

Utilisation des barres de défilement dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Définition de menus dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Affichage d’une indication visuelle pour une opération longue durée dans une application mobile . . . . . . . . . . . . . . . . . . . . . 58

Définition de transitions dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

iii

Chapitre 4 : Conception d’applications et flux de travail

Activation de la persistance dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Prise en charge de plusieurs tailles d’écran et valeurs PPP dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Chapitre 5 : Texte

Utilisation de texte dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

Interventions de l’utilisateur liées à du texte dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

Prise en charge du clavier à l’écran dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

Intégration de polices dans une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

Utilisation de texte HTML dans des contrôles mobiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Chapitre 6 : Habillage

Notions de base sur l’habillage mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

Création d’habillages pour une application mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

Application d’un habillage mobile personnalisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Sommaire

Chapitre 7 : Exécution et débogage des applications mobiles

Gestion des configurations de lancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Exécution et débogage d’une application mobile sur le bureau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Exécution et débogage d’une application mobile sur un périphérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Chapitre 8 : Groupement et exportation d’une application mobile

Exportation de packages Android APK pour publication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

Exportation de packages Apple iOS pour publication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

Chapitre 9 : Déploiement

Déploiement d’une application sur un périphérique mobile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

Développement et déploiement d’une application mobile sur la ligne de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

Dernière mise à jour le 8/7/2011

Chapitre 1 : Prise en main

Premiers pas avec les applications mobiles

La version Adobe Flex 4.5 permet d’utiliser Flex et Adobe Flash Builder sur les smartphones et les tablettes. En tirant profit d’Adobe AIR, vous pouvez maintenant développer des applications mobiles dans Flex avec la même aisance et la même qualité que sur les plateformes d’ordinateurs de bureau.

De nombreux composants Flex existants ont été étendus pour fonctionner sur les périphériques mobiles, y compris l’ajout de la prise en charge du défilement tactile. Flex 4.5 contient également un ensemble de nouveaux composants conçus pour simplifier la création d’applications qui suivent les modèles de conception standard pour les téléphones et les tablettes.

Flash Builder a également été mis à jour pour fournir de nouvelles fonctionnalités pour la prise en charge du développement d’applications pour les périphériques mobiles. Avec Flash Builder, vous pouvez développer, tester et déboguer des applications sur votre ordinateur de bureau ou directement sur votre périphérique mobile.

Conception d’une application mobile

En raison de la taille d’écran réduite des périphériques mobiles, les applications mobiles sont généralement conçues différemment des applications pour navigateur. Lors du développement d’applications mobiles, vous divisez en général le contenu en une série de vues à afficher sur un périphérique mobile.

Chaque vue contient les composants qui se rapportent à une tâche individuelle ou qui contiennent un ensemble unique d’informations. L’utilisateur passe généralement d’une vue à l’autre pour obtenir plus de détails en appuyant sur les composants d’une vue. L’utilisateur peut alors utiliser le bouton Retour du périphérique pour retourner à une vue précédente ou intégrer la navigation dans l’application.

Dans l’exemple suivant, la vue initiale de l’application montre une liste de produits :

A. Sélectionnez un élément de liste pour changer les vues dans l’application. B. Utilisez le bouton Retour du périphérique pour retourner à la vue précédente.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Prise en main

L’utilisateur sélectionne un produit dans la liste pour obtenir plus d’informations. La sélection change la vue pour afficher une description détaillée du produit.

Si vous concevez une application pour les plateformes mobiles, Web et d’ordinateurs de bureau, concevez des interfaces utilisateur distinctes pour chaque plateforme. Toutefois, les applications peuvent partager un code d’accès au modèle et aux données sous-jacent entre toutes les plateformes.

Création d’applications pour téléphones et tablettes

Pour une application destinée à des tablettes, les limites de taille d’écran sont moins contraignantes qu’avec les téléphones. Vous n’êtes pas tenu de structurer une application de tablette autour de petites vues. A la place, vous pouvez créer l’application en utilisant le conteneur Spark Application standard avec les composants et habillages mobiles pris en charge.

Remarque : vous pouvez créer une application pour un téléphone mobile basée sur le conteneur Spark Application. Toutefois, vous utilisez généralement les conteneurs ViewNavigatorApplication et TabbedViewNavigatorApplication à la place.

Créez un projet mobile dans Flash Builder pour les tablettes comme vous le feriez pour les téléphones. Les applications pour les tablettes et les téléphones requièrent le même thème mobile pour tirer profit des composants et habillages optimisés pour les applications mobiles.

Création d’applications mobiles dans Flash Builder

Flash Builder introduit un flux de travail productif de conception, création et débogage dans le développement mobile. L’objectif des fonctionnalités mobiles dans Flash Builder est de rendre le développement d’une application mobile basée sur ActionScript ou Flex aussi simple que le développement d’une application de bureau ou Web.

Flash Builder offre deux options pour les tests et le débogage. Vous pouvez lancer et déboguer l’application sur l’ordinateur de bureau en utilisant AIR Debug Launcher (ADL). Pour bénéficier d’un contrôle plus important, lancez et déboguez l’application directement sur un périphérique mobile. Dans les deux cas, vous pouvez utiliser les capacités de débogage de Flash Builder, y compris la définition de points d’arrêt et l’examen de l’état de l’application à l’aide des volets Variables et Expressions.

Lorsque votre application est prête à être déployée, utilisez le processus Exporter vers une version validée, tout comme vous le feriez pour préparer une application de bureau ou Web. La principale différence tient au fait que lorsque vous exportez une version validée d’un projet mobile, Flash Builder groupe la version en tant que programme d’installation natif et non pas en tant que fichier .air. Par exemple, sur Android, Flash Builder produit un fichier .apk qui ressemble à un package d’application Android natif. Le programme d’installation natif permet de distribuer les applications AIR de la même façon que les applications natives sur chaque plateforme.

Déploiement d’applications mobiles dans Flash Builder

Déployez des applications mobiles créées dans Flex en utilisant Adobe AIR pour les périphériques mobiles. Tout périphérique sur lequel vous souhaitez déployer une application mobile doit prendre en charge AIR.

Vos applications peuvent bénéficier pleinement de l’intégration d’AIR à la plateforme mobile. Par exemple, une application mobile peut gérer un bouton de retour et de menu matériel et accéder au stockage local. Vous pouvez également bénéficier de toutes les fonctions fournies par AIR pour les périphériques mobiles. Ces fonctions comprennent la géolocalisation, l’accéléromètre et l’intégration d’une caméra.

Sur un périphérique mobile, il n’est pas nécessaire d’installer AIR avant d’exécuter une application créée dans Flex. La première fois qu’un utilisateur exécute une application créée dans Flex, l’utilisateur est invité à télécharger AIR.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Prise en main

Pour vous familiariser avec AIR et pour plus d’informations sur les fonctionnalités de AIR, consultez les documents suivants :

• A propos d’Adobe AIR

• Appel et arrêt d’une application AIR

• Utilisation des informations d’exécution AIR et du système d’exploitation

• Utilisation des fenêtres natives AIR

• Utilisation des bases de données SQL locales dans AIR

Lors du développement d’applications mobiles, vous ne pouvez pas utiliser les composants Flex suivants pour AIR : WindowedApplication et Window. A la place, utilisez les conteneurs ViewNavigatorApplication et TabbedViewNavigatorApplication. Dans le cas du développement d’applications destinées à des tablettes, vous pouvez également utiliser le conteneur Spark Application.

Pour plus d’informations, voir Utilisation des composants Flex AIR et « Définition d’une application mobile et d’un

écran de démarrage » à la page 27.

Utilisation du thème Mobile dans votre application

Un thème définit l’aspect et l’ergonomie des composants visuels d’une application. Un thème peut simplement définir la palette chromatique ou la police commune d’une application, ou peut redéfinir entièrement l’habillage de l’ensemble des composants utilisés par l’application.

Vous pouvez définir des styles CSS sur les composants Flex uniquement si le thème actuel comprend ces styles. Pour déterminer si le thème actuel prend en charge le style CSS, affichez l’entrée du style dans le Guide de référence

ActionScript 3.0 pour la plate-forme Adobe Flash.

Flex prend en charge trois thèmes principaux : Mobile, Spark et Halo. Le thème Mobile définit l’aspect par défaut des composants Flex lorsque vous créez une application mobile. Afin de rendre certains composants Flex compatibles avec le thème Mobile, Adobe a créé de nouveaux habillages pour les composants. Par conséquent, certains composants ont les habillages spécifiques d’un thème.

Les applications créées avec Flex peuvent cibler différents périphériques mobiles, chacun présentant des tailles et des résolutions d’écran différentes. Flex simplifie le processus de production d’applications indépendantes de la résolution en proposant des habillages indépendants des PPP pour les composants mobiles. Pour plus d’informations sur les habillages mobiles, voir « Notions de base sur l’habillage mobile » à la page 96.

Pour plus d’informations sur les styles et les thèmes, voir Styles et thèmes et « Styles mobiles » à la page 96.

Ressources de la communauté

Découvrez les nouvelles fonctions intégrées dans Flex 4.5 et Flash Builder 4.5, dans :

• Introducing Adobe Flex 4.5 SDK de Deepa Subramaniam, chef de produit chez Adobe.

• Développement mobile à l’aide d’Adobe Flex 4.5 SDK et de Flash Builder 4.5 de Narciso Jaramillo, chef de produit

chez Adobe.

• Nouveautés de Flash Builder 4.5 d’Andrew Shorten, chef de produit chez Adobe.

Le Pôle de développement Flex contient de nombreuses ressources conçues pour vous aider à commencer à créer des applications mobiles à l’aide de Flex 4.5 :

• Articles, liens et didacticiels de prise en main

• Exemples d’applications réelles créées dans Flex

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Prise en main

• Livre de cuisine Flex Cookbook, qui contient les réponses aux problèmes de codage courants

• Liens vers la communauté Flex et vers d’autres sites dédiés à Flex

Adobe TV est une autre ressource, qui contient des vidéos élaborées par des ingénieurs, des experts produit et des

clients Adobe sur le développement d’applications dans Flex. L’une des vidéos disponibles est Création de votre

première application mobile dans Flash Builder 4.5.

Vous trouverez ici des informations sur Flash Builder 4.5 mobile compilées par Holly Schinsky.

Mark Doherty, évangéliste Adobe, a publié une vidéo sur la génération d’applications pour les ordinateurs de

bureau, les téléphones portables et les tablettes.

James Ward, spécialiste d’Adobe, propose une vidéo concernant la génération d’applications mobiles avec

Flex 4.5.

Le blogueur Joseph Labrecque a communiqué sur une démonstration de Flex 4.5 mobile.

Le blogueur Fabio Biondi a communiqué sur la création d’un lecteur YouTube utilisant AIR pour les dispositifs

Android à l’aide de Flash Builder.

Différences entre le développement d’applications

mobiles, de bureau et de navigateur

Utilisez Flex pour développer des applications pour les environnements de déploiement suivants :

Navigateur Déployez l’application en tant que fichier SWF à utiliser dans Flash Player s’exécutant dans un navigateur.

Bureau Déployez une application AIR autonome pour un ordinateur de bureau, tel qu’un ordinateur exécutant

Windows ou un Macintosh.

Mobile Déployez une application AIR autonome pour un périphérique mobile, tel qu’un téléphone ou une tablette.

Les exécutions sur Flash Player et AIR sont similaires. Vous pouvez effectuer la plupart des mêmes opérations dans l’un ou l’autre des environnements d’exécution. AIR vous permet non seulement de déployer des applications autonomes en dehors d’un navigateur, mais vous fournit en outre une intégration étroite à la plateforme hôte. Cette intégration permet par exemple d’accéder au système de fichiers du périphérique, de créer et d’utiliser des bases de données SQL locales, etc.

Considérations liées à la conception et au développement d’applications mobiles

Les applications destinées aux périphériques mobiles à écran tactile diffèrent des applications de bureau et de navigateur de plusieurs manières :

• Pour permettre une manipulation simple par entrée tactile, les composants mobiles disposent généralement de

zones actives plus étendues que dans les applications de bureau ou de navigateur.

• Les modèles d’interaction pour les actions telles que le défilement sont différents sur les périphériques à écran

tactile.

• En raison de la surface limitée de l’écran, les applications mobiles sont conçues en général de façon à présenter à

l’écran seulement une faible partie de l’interface utilisateur à la fois.

• La conception de l’interface utilisateur doit prendre en compte les différences de résolution d’écran entre les

périphériques.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Prise en main

• Les performances d’UC et d’unité GPU sont plus limitées sur les téléphones et les tablettes que sur les périphériques

de bureau.

• En raison de la mémoire limitée disponible sur les périphériques mobiles, les applications doivent être soucieuses

d’économiser la mémoire.

• Les applications mobiles peuvent être fermées et redémarrées à tout moment, par exemple, lorsque le périphérique

reçoit un appel ou un texto.

Par conséquent, la création d’une application pour un périphérique mobile ne se résume pas au redimensionnement d’une application de bureau pour un écran de plus petite taille. Flex vous permet de créer différentes interfaces utilisateur appropriées pour chaque facteur de forme, tout en partageant le code d’accès au modèle et aux données sous-jacent entre les projets mobiles, de navigateur et de bureau.

Restrictions liées à l’utilisation de Spark et des composants MX dans une application mobile

Utilisez le composant Spark défini lors de la création des applications mobiles dans Flex. Les composants Spark sont définis dans les composants Spark.* packages. Toutefois, pour des raisons de performance ou parce que tous les composants Spark n’ont pas d’habillage pour le thème Mobile, les applications mobiles ne prennent pas en charge la totalité des composants Spark.

A l’exception des contrôles graphiques MX et du contrôle MX Spacer, les applications mobiles ne prennent pas en charge l’ensemble de composants MX défini dans les packagesmx.*.

Le tableau ci-dessous répertorie les composants que vous pouvez utiliser, que vous ne pouvez pas utiliser ou qui requièrent un soin particulier pour être utilisés dans une application mobile :

Composant Composant Utilisation

Spark ActionBar

Spark BusyIndicator

Spark TabbedViewNavigator

Spark TabbedViewNavigatorApplication

Spark Button

Spark CheckBox

Spark DataGroup

Spark Group/HGroup/VGroup/TileGroup

Spark Image/BitmapImage

Spark Label

Autres composants Spark habillables Déconseillé Les composants Spark habillables autres

Spark View

Spark ViewMenu

Spark ViewNavigator

Spark ViewNavigatorApplication

Spark List

Spark RadioButton/RadioButtonGroup

Spark SkinnableContainer

Spark Scroller

Spark TextArea

Spark TextInput

dans une application mobile ?

Oui Ces nouveaux composants prennent en

Oui La plupart de ces composants disposent

Remarques

charge les applications mobiles.

d’habillages pour le thème Mobile. Label, Image et BitmapImage peuvent être utilisés, même s’ils ne disposent pas d’un habillage mobile.

Certains conteneurs de présentation Spark, comme Group et ses sous-classes, n’ont pas d’habillage. Par conséquent, vous pouvez les utiliser dans une application mobile.

que ceux figurant dans la liste ci-dessus sont déconseillés car ils n’ont pas d’habillage pour le thème Mobile. Si le composant n’a pas d’habillage pour le thème Mobile, vous pouvez en créer un pour votre application.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Prise en main

Composant Composant Utilisation

Spark DataGrid Spark RichEditableText

Spark RichText

Composants MX autres que Spacer et les graphiques

MX Spacer Oui Spacer n’utilise pas d’habillage, de sorte

Composants graphiques MX Oui, mais

dans une application mobile ?

Déconseillé Ces composants sont déconseillés pour

Non Les applications mobiles ne prennent pas

avec des implications pour les performance s.

Remarques

des raisons de performance. Même si vous pouvez les utiliser dans une application mobile, cela risque d’affecter les performances.

En ce qui concerne le contrôle DataGrid, les performances sont basées sur la quantité de données dont vous effectuez le rendu. Quant aux contrôles RichEditableText et RichText, leur performance est basée sur la quantité de texte et sur le nombre de contrôles présents dans l’application.

en charge les composants MX tels que MX Button, CheckBox, List ou DataGrid. Ces composants correspondent aux composants Flex 3 dans les contrôles MX* et les conteneurs MX*.

qu’il peut être utilisé dans une application mobile.

Vous pouvez utiliser les contrôles graphiques MX, tels que AreaChart et BarChart, dans une application mobile. Les contrôles graphiques MX sont dans les graphiques MX.mx.*.

Toutefois, leurs performances sur un périphérique mobile peuvent être amoindries selon la taille et le type des données graphiques.

Par défaut, Flash Builder n’inclut pas les composants MX dans le chemin d’accès aux bibliothèques des projets mobiles. Pour utiliser les composants graphiques MX dans une application, ajoutez les fichiers mx.swc et charts.swc à votre chemin d’accès à la bibliothèque.

Les fonctionnalités Flex ci-dessous ne sont pas prises en charge dans les applications mobiles :

• Pas de prise en charge des opérations de glisser-déposer.

• Pas de prise en charge du contrôle ToolTip.

• Pas de prise de charge des bibliothèques RSL.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Prise en main

Considérations liées aux performances avec les applications mobiles

En raison des contraintes de performances qui pèsent sur les périphériques mobiles, certains aspects du développement d’applications mobiles diffèrent de ceux du développement d’applications de navigateur et de bureau. Les considérations liées aux performances comprennent :

• Rédaction des rendus d’élément dans ActionScript

Pour les applications mobiles, le défilement dans les listes doit être aussi performant que possible. Rédigez des rendus d’élément dans ActionScript pour bénéficier de performances optimales. Il est possible de rédiger les rendus d’élément dans MXML, mais les performances de vos applications peuvent en souffrir.

Flex fournit deux rendus d’élément qui sont optimisés à utiliser dans une application mobile : spark.components.LabelItemRenderer et spark.components.IconItemRenderer. Pour plus d’informations à propos de ces rendus d’élément, voir Using a mobile item renderer with a Spark list-based control.

Pour plus d’informations sur la création de rendus d’élément personnalisés dans ActionScript, voir Custom Spark item renderers. Pour plus d’informations sur les différences entre les rendus d’élément mobiles et de bureau, voir Differences between mobile and desktop item renderers.

• Utilisation d’ActionScript et de graphiques FXG compilés ou de bitmaps pour développer des habillages

personnalisés

Les habillages mobiles livrés avec Flex sont rédigés dans ActionScript avec des graphiques FXG compilés afin d’offrir des performances optimales. Vous pouvez rédiger les habillages dans MXML, mais les performances de votre application peuvent en souffrir, selon le nombre de composants qui utilisent les habillages MXML. Pour des performances optimales, rédigez les habillages dans ActionScript et utilisez des graphiques FXG compilés. Pour plus d’informations, voir Habillage Spark et Graphiques FXG et MXML.

• Utilisation de composants de texte indépendants de l’infrastructure Text Layout Framework (TLF)

Bon nombre des contrôles de texte Spark dépendent de TLF. L’utilisation de contrôles TLF dans une application mobile peut affecter les performances. Pour plus d’informations à propos de TLF, voir About the Spark text controls.

Le contrôle Spark Label ne dépend pas de TLF. Les contrôles Spark TextInput et TextArea disposent d’habillages pour le thème mobile qui ne dépendent pas de TLF. Pour des résultats optimaux, utilisez les contrôles Label, TextInput et TextArea dans votre application, sauf lorsque vous rédigez des rendus d’élément personnalisés. Dans les rendus d’élément personnalisés, utilisez le contrôle StyleableTextField. Pour plus d’informations, voir Custom Spark item renderers.

Les contrôles Spark RichText et RichEditableText dépendent de TLF. Vous pouvez utiliser ces contrôles pour afficher un contenu riche, mais leur utilisation risque de nuire aux performances.

• Soyez prudent lorsque vous utilisez des composants graphiques MX dans une application mobile.

Vous pouvez utiliser les contrôles graphiques MX, tels que les contrôles AreaChart et BarChart, dans une application mobile. Toutefois, ils peuvent nuire aux performances selon la taille et le type des données graphiques.

Le blogueur Nahuel Foronda a créé une série d’articles sur Mobile ItemRenderer dans ActionScript.

Le blogueur Rich Tretola a créé une entrée de cookbook sur la création d’une liste avec un élément ItemRenderer

pour une application mobile.

Dernière mise à jour le 8/7/2011

Chapitre 2 : Environnement de développement

Création d’une application Android dans Flash Builder

Voici un flux de travail général permettant de créer une application mobile Flex pour la plateforme Google Android. Ce flux de travail suppose que vous avez déjà conçu votre application mobile. Pour plus d’informations, voir « Conception d’une application mobile » à la page 1 .

Exigences liées à AIR

Les projets mobiles Flex et les projets mobiles ActionScript requièrent AIR 2.6. Vous pouvez exécuter des projets mobiles sur des périphériques physiques qui prennent en charge AIR 2.6. Vous pouvez installer AIR 2.6 sur des périphériques Android qui exécutent Android 2.2 ou version ultérieure.

Remarque : si vous ne disposez pas d’un périphérique prenant en charge AIR 2.6, vous pouvez utiliser Flash Builder pour lancer et déboguer des applications mobiles sur le bureau.

Chaque version du SDK Flex inclut la version requise d’Adobe AIR. Si vous avez installé des applications mobiles sur un périphérique exécutant une version antérieure du SDK Flex, désinstallez AIR du périphérique. Flash Builder installe la version correcte d’AIR lorsque vous exécutez ou déboguez une application mobile sur un périphérique.

Création d’une application

1 Dans Flash Builder, sélectionnez Fichier > Nouveau > Projet Flex Mobile.

Un projet Flex Mobile est un type particulier de projet AIR. Suivez les invites de l’assistant de nouveau projet comme vous le feriez pour tout autre projet AIR dans Flash Builder. Pour plus d’informations, voir Création de projets mobiles Flex.

Pour définir des préférences mobiles spécifiques à Android, voir « Définition des préférences de projet mobile » à la page 12.

Lorsque vous créez un projet Flex Mobile, Flash Builder génère les fichiers suivants pour le projet :

• ProjectName.mxml

Le fichier d’application par défaut pour le projet.

Par défaut, Flash Builder attribue à ce fichier le même nom qu’au projet. Si le nom du projet contient des caractères non autorisés par ActionScript, Flash Builder nomme ce fichier Main.mxml. Le fichier MXML contient la balise Spark Application de base du projet. La balise Spark Application peut être ViewNavigatorApplication ou TabbedViewNavigatorApplication.

Généralement, vous n’ajoutez pas directement de contenu au fichier d’application par défaut, à l’exception du contenu ActionBar affiché dans toutes les vues. Pour ajouter du contenu au contrôle ActionBar, définissez les propriétés

navigatorContent, titleContent ou actionContent.

• ProjectNameHomeView.mxml

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

Le fichier représentant la vue initiale du projet. Flash Builder place le fichier dans un package de vues. L’attribut

firstView de la balise ViewNavigatorApplication dans ProjectName.mxml spécifie ce fichier comme vue

d’ouverture par défaut de l’application.

Pour plus d’informations sur la définition des vues, voir « Définition de vues dans une application mobile » à la page 30.

Vous pouvez aussi créer un projet mobile ActionScript seulement. Voir « Création d’un projet mobile

ActionScript » à la page 11.

2 (Facultatif) Ajoutez du contenu au contrôle ActionBar du fichier de l’application principale.

Le contrôle ActionBar affiche le contenu et les fonctionnalités qui s’appliquent à l’application ou à la vue actuelle de l’application. Ajoutez ici le contenu que vous souhaitez afficher dans toutes les vues de l’application. Voir « Définition de contrôles de navigation, de titre et d’action dans une application mobile » à la page 45.

3 Disposez le contenu de la vue initiale de votre application.

Utilisez Flash Builder en mode Création ou en mode Source pour ajouter des composants à une vue.

Utilisez uniquement des composants pris en charge par Flash pour le développement mobile. En mode Création comme en mode Source, Flash Builder vous guide dans l’utilisation des composants pris en charge. Voir « Interface

utilisateur et présentation » à la page 19

Dans la vue, ajoutez du contenu au contrôle ActionBar qui n’est visible que dans cette vue.

4 (Facultatif) Ajoutez toutes les vues que vous souhaitez inclure dans votre application.

Dans l’Explorateur de packages Flash Builder, sous le menu contextuelle correspondant au package de vues de votre projet, sélectionnez Nouveau composant MXML. L’assistant Nouveau composant MXML vous guide lors de la création de la vue.

Pour plus d’informations sur les vues, voir « Définition de vues dans une application mobile » à la page 30.

5 (Facultatif) Ajoutez des rendus d’élément optimisés pour les applications mobiles pour les composants List.

Adobe fournit IconItemRenderer, un rendu d’élément basé sur ActionScript à utiliser avec les applications mobiles. Voir Using a mobile item renderer with a Spark list-based control.

6 Configurez les configurations de lancement pour exécuter et déboguer l’application.

Vous pouvez exécuter ou déboguer l’application sur le bureau ou sur un périphérique.

Une configuration de lancement est requise pour exécuter ou déboguer une application à partir de Flash Builder. La première fois que vous exécutez ou déboguez une application mobile, Flash Builder vous invite à configurer une configuration de lancement.

Lors de l’exécution ou du débogage d’une application mobile sur un périphérique, Flash Builder installe l’application sur le périphérique.

Voir « Exécution et débogage des applications mobiles » à la page 111.

7 Exportez l’application en tant que package d’installation.

Utilisez Exporter vers une version validée pour créer des packages qui pourront être installés sur des périphériques mobiles. Flash Builder crée des packages pour la plateforme sélectionnée pour l’exportation. Voir « Exportation de

packages Android APK pour publication » à la page 117.

Brent Arnold, expert Flex certifié par Adobe, a conçu les didacticiels vidéos suivants pour vous permettre de :

•Créer une application Flex mobile simple pour la plateforme Android

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

• Créer une application Flex mobile avec plusieurs vues

• Créer une application Flex mobile à l’aide d’un contrôle de listes utilisant Spark

Création d’une application iOS dans Flash Builder

Voici un flux de travail général permettant de créer une application mobile ActionScript pour la plateforme Apple iOS.

1 Avant de commencer à créer l’application mobile ActionScript, suivez la procédure répertoriée dans la section

« Connexion de périphériques Apple iOS » à la page 18.

2 Dans Flash Builder, sélectionnez Fichier > Nouveau > Projet ActionScript Mobile.

Sélectionnez la plateforme cible Apple iOS et définissez les préférences de projet mobile. Pour plus d’informations sur la définition des préférences de projet mobile, voir « Définition des préférences de projet mobile » à la page 12.

Suivez les invites de l’assistant de nouveau projet comme vous le feriez dans tout autre assistant de création de projets dans Flash Builder. Pour plus d’informations, voir Création de projets mobiles ActionScript.

3 Rédigez le code de l’application dans le fichier d’application ActionScript principal.

4 Configurez les configurations de lancement pour exécuter et déboguer l’application. Vous pouvez exécuter ou

déboguer l’application sur le bureau ou sur un périphérique connecté.

Pour plus d’informations, voir « Débogage d’une application sur un périphérique Apple iOS » à la page 115.

5 Exportez ou déployez l’application en tant qu’application de package iOS (IPA, iOS Package Application).

Pour plus d’informations, voir « Exportation de packages Apple iOS pour publication » à la page 118 et « Déploiement d’une application sur un périphérique Apple iOS » à la page 119.

Voir aussi

Création d’une application mobile (vidéo)

Création d’une application BlackBerry Tablet OS dans Flash Builder

Flash Builder 4.5.1 comprend un plug-in de Research In Motion (RIM) qui permet de créer et grouper des applications Flex et ActionScript pour BlackBerry® Tablet OS.

Création d’une application

Voici un flux de travail général permettant de créer des applications pour BlackBerry Tablet OS.

1 Avant de commencer à créer une application mobile, installez le SDK BlackBerry Tablet OS pour AIR depuis le site

de développement d’applications BlackBerry Tablet OS.

Le SDK BlackBerry Tablet OS pour AIR fournit des API qui permettent de créer des applications Flex et ActionScript basées sur AIR.

Pour plus d’informations sur l’installation du SDK BlackBerry Tablet OS, voir le guide de prise en main BlackBerry

Tablet OS.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

2 Pour créer une application AIR basée sur Flex, dans Flash Builder, sélectionnez Fichier > Nouveau > Projet Flex

Mobile.

Suivez les invites de l’assistant de nouveau projet comme vous le feriez pour tout autre projet AIR dans Flash Builder. Veillez à sélectionner BlackBerry Tablet OS comme plateforme cible.

Pour plus d’informations, voir Création de projets mobiles Flex.

3 Pour créer une application AIR basée sur ActionScript, dans Flash Builder, sélectionnez Fichier > Nouveau > Projet

ActionScript Mobile.

Suivez les invites de l’assistant de nouveau projet comme vous le feriez pour tout autre projet AIR dans Flash Builder. Veillez à sélectionner BlackBerry Tablet OS comme plateforme cible.

Pour plus d’informations, voir Création de projets mobiles ActionScript.

Signature, groupement et déploiement d’une application

Pour plus d’informations sur la signature, le groupement et le déploiement de l’application, voir le guide de

développement du SDK BlackBerry Tablet OS pour Adobe AIR par RIM.

Lisez également l’article relatif à l’utilisation de Flash Builder afin de grouper des applications pour les

périphériques BlackBerry Tablet OS par Andrew Shorten, chef de produit Adobe.

Vous trouverez des ressources supplémentaires sur le développement BlackBerry Tablet OS provenant d’Adobe et de RIM sur la page Adobe Developer Connection.

Création d’un projet mobile ActionScript

Utilisez Flash Builder pour créer une application mobile ActionScript. L’application que vous créez est basée sur l’API d’Adobe AIR.

1 Sélectionnez Fichier > Nouveau > Projet mobile ActionScript.

2 Entrez un nom de projet et un emplacement. L’emplacement par défaut est l’espace de travail actuel.

3 Utilisez le SDK Flex 4.5 par défaut qui prend en charge le développement d’applications mobiles.

Cliquez sur Suivant.

4 Sélectionnez les plateformes cibles pour votre application et spécifiez les paramètres de projet mobile pour chaque

plateforme.

Pour plus d’informations sur les paramètres de projet mobile, voir « Définition des préférences de projet mobile » à la page 12.

5 Cliquez sur Terminer ou sur Suivant pour indiquer d’autres options de configuration et chemins de génération.

Pour plus d’informations sur les options de configuration de projet et les chemins de génération, voir Chemins de génération et autres options de configuration du projet.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

Définition des préférences de projet mobile

Définition des configurations de périphériques

Flash Builder utilise des configurations de périphériques pour afficher des aperçus des tailles d’écran des périphériques dans la vue Création, ou pour lancer des applications sur le bureau à l’aide d’AIR Debug Launcher (ADL). Voir « Gestion des configurations de lancement » à la page 111.

Pour définir des configurations de périphériques, ouvrez la fenêtre Préférences et sélectionnez Flash Builder > Configuration des périphériques.

Flash Builder fournit plusieurs configurations de périphérique par défaut. Vous pouvez ajouter, modifier ou supprimer des configurations de périphérique supplémentaires. Vous ne pouvez pas modifier les configurations par défaut fournies par Flash Builder.

Cliquez sur le bouton Restaurer les valeurs par défaut pour rétablir les configurations de périphériques par défaut, sans supprimer les configurations que vous avez ajoutées. De plus, si vous avez ajouté une configuration de périphérique avec un nom correspondant à celui d’une configuration par défaut, Flash Builder remplace la configuration ajoutée par les paramètres par défaut.

Les configurations de périphérique contiennent les propriétés suivantes :

Propriété Description

Nom du périphérique

Plateforme Plateforme du périphérique. Sélectionnez une plateforme dans la liste des plateformes prises

Taille plein écran Largeur et hauteur de l’écran du périphérique.

Taille d’écran utilisable

Pixels par pouce Pixels par pouce sur l’écran du périphérique.

Nom unique du périphérique.

en charge.

Taille standard d’une application sur le périphérique. Il s’agit de la taille prévue d’une application lancée en mode non-plein écran, en tenant compte du dispositif chrome du système, comme la barre d’état.

Choix des plateformes cibles

Flash Builder prend en charge les plateformes cibles en fonction du type d’application.

Pour sélectionner une plateforme, ouvrez la fenêtre Préférences et sélectionnez Flash Builder > Plateformes cibles.

Pour tous les plug-ins tiers, reportez-vous à la documentation correspondante.

Choix d’un modèle d’application

Lorsque vous créez une application mobile, vous pouvez faire un choix parmi les modèles d’application suivants :

Vide Utilise la balise Spark Application en tant qu’élément d’application de base.

Utilisez cette option pour créer une application personnalisée sans utiliser la navigation standard dans les vues.

Application basée sur une vue Utilise la balise Spark ViewNavigatorApplication en tant qu’élément d’application de

base pour créer une application dotée d’une vue unique.

Vous pouvez spécifier le nom de la vue initiale.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

Application à onglets Utilise la balise Spark TabbedViewNavigatorApplication comme élément d’application de base

pour créer une application basée sur des onglets.

Pour ajouter un onglet, saisissez le nom de l’onglet et cliquez sur Ajouter. Vous pouvez modifier l’ordre des onglets en cliquant sur Haut et Bas. Pour supprimer un onglet d’une application, sélectionnez un onglet et cliquez sur Supprimer.

Le nom de la vue correspond au nom de l’onglet auquel est ajouté le mot « View ». Par exemple, si vous nommez un onglet FirstTab, Flash Builder génère une vue nommée FirstTabView.

Pour chaque onglet que vous créez, un nouveau fichier MXML est généré dans le package « Views ».

Remarque : le nom du package n’est pas configurable à l’aide de l’assistant Projet Flex Mobile.

Les fichiers MXML sont générés conformément aux règles suivantes :

• Si le nom de l’onglet est un nom de classe ActionScript valide, Flash Builder génère le fichier MXML en ajoutant le

suffixe « View » au nom de l’onglet.

• Si le nom de l’onglet n’est pas un nom de classe valide, Flash Builder modifie le nom de l’onglet en supprimant les

caractères non valides et en insérant des caractères initiaux valides. Si le nom modifié n’est pas acceptable, Flash Builder modifie le nom de fichier MXML en le remplaçant par « ViewN », où N correspond à la position de la vue, en commençant par N=1.

Brent Arnold, expert Flex certifié par Adobe, a créé un didacticiel vidéo sur l’utilisation du modèle d’application

à onglets.

Choix des autorisations d’une application mobile

Lorsque vous créez une application mobile, vous pouvez spécifier ou modifier les droits par défaut d’une plateforme cible. Les autorisations sont spécifiées au moment de la compilation et ne peuvent pas être modifiées dans l’environnement d’exécution.

Commencez par sélectionner la plateforme cible, puis définissez les autorisations pour chaque plateforme, le cas échéant. Vous pourrez modifier les autorisations par la suite dans le fichier XML descripteur de l’application.

Des plug-ins tiers fournissent une prise en charge de plateformes supplémentaires pour les projets Flex et ActionScript. Pour les autorisations spécifiques aux plateformes, reportez-vous à la documentation du périphérique.

Autorisations pour la plateforme Google Android

Pour la plateforme Google Android, vous pouvez définir les autorisations suivantes :

INTERNET Autorise les demandes réseau et le débogage à distance.

L’autorisation INTERNET est sélectionnée par défaut. Si vous désélectionnez ce droit, vous ne pouvez pas déboguer votre application sur un périphérique.

WRITE_EXTERNAL_STORAGE Autorise l’écriture sur un périphérique externe.

Sélectionnez ce droit pour permettre à l’application d’écrire sur une carte mémoire externe du périphérique.

READ_PHONE_STATE Coupe le son au cours d’un appel entrant.

Sélectionnez ce droit pour permettre à l’application de couper le son au cours des appels téléphoniques. Par exemple, vous pouvez sélectionner ce droit si votre application lit les sons en arrière-plan.

ACCESS_FINE_LOCATION Autorise l’accès à un emplacement GPS.

Sélectionnez ce droit pour permettre à l’application d’accéder aux données GPS à l’aide de la classe Geolocation.

DISABLE_KEYGUARD and WAKE_LOCK Interdit la mise en veille du périphérique.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

Sélectionnez ce droit pour empêcher le périphérique de se mettre en veille à l’aide des paramètres de la classe SystemIdleMode.

CAMERA Permet d’accéder à une caméra.

Sélectionnez ce droit pour permettre à l’application d’accéder à une caméra.

RECORD_AUDIO Permet d’accéder à un microphone.

Sélectionnez ce droit pour permettre à l’application d’accéder à un microphone.

ACCESS_NETWORK_STATE and ACCESS_WIFI_STATE Autorise l’accès aux informations concernant les interfaces

réseau associées au périphérique.

Sélectionnez ce droit pour permettre à l’application d’accéder aux informations réseau à l’aide de la classe NetworkInfo.

Pour plus d’informations sur la définition des propriétés des applications mobiles, voir la Documentation Adobe AIR.

Autorisations pour la plateforme Apple iOS

La plateforme Apple iOS utilise la validation dans l’environnement d’exécution pour les autorisations au lieu des autorisations prédéfinies. En d’autres termes, si une application souhaite accéder à une fonction spécifique de la plateforme Apple iOS qui requiert des droits d’utilisateur, une fenêtre contextuelle apparaît, demandant l’autorisation.

Choix des paramètres de plateforme

Les paramètres de plateforme vous permettent de sélectionner une gamme de périphériques cibles. Selon la plateforme sélectionnée, vous pouvez choisir le périphérique cible ou une gamme de périphériques cibles. Vous pouvez sélectionner un périphérique spécifique ou tous les périphériques pris en charge par la plateforme.

Paramètres de plateforme pour la plateforme Google Android

il n’existe pas de paramètres spécifiques à la plateforme Google Android.

Paramètres de plateforme pour la plateforme Apple iOS

Pour un projet mobile Flex ou un projet mobile ActionScript, vous pouvez spécifier les périphériques cibles suivants pour la plateforme Apple iOS :

iPhone/iPod Touch Les applications utilisant cette gamme cible sont répertoriées comme compatibles uniquement

avec les périphériques iPhone et iPod Touch dans le magasin Apple App.

iPad Les applications utilisant cette gamme cible sont répertoriées comme compatibles uniquement avec les

périphériques iPad dans le magasin Apple App.

Tous Les applications utilisant cette gamme cible sont répertoriées comme compatibles avec les périphériques

iPhone/iPod Touch et iPad dans l’App Store d’Apple. Il s’agit de l’option par défaut.

Choix des paramètres d’application

Réorientation automatique Fait pivoter l’application lorsque l’utilisateur tourne le périphérique. Lorsque ce

paramètre n’est pas activé, votre application apparaît toujours dans la même orientation.

Plein écran Affiche l’application en mode plein écran sur le périphérique. Lorsque ce paramètre est activé, la barre

d’état du périphérique n’apparaît pas au-dessus de l’application. Votre application remplit tout l’écran.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

Si vous souhaitez cibler votre application vers plusieurs types de périphériques aux densités d’écran variables, sélectionnez Redimensionner automatiquement l’application pour différentes densités d’écran. La sélection de cette option redimensionne automatiquement l’application et gère les changements de densité des périphériques, le cas échéant. Voir « Définition du redimensionnement d’application » à la page 15.

Définition du redimensionnement d’application

Vous utilisez le redimensionnement d’application mobile pour créer une application mobile unique compatible avec des périphériques de taille d’écran et de densité différentes.

Les écrans des périphériques mobiles possèdent des densités d’écran, ou valeurs PPP(points par pouce), variables. Vous pouvez spécifier une valeur de PPP de 160, 240 ou 320, selon la densité d’écran du périphérique cible. Lorsque vous activez le redimensionnement automatique, Flex optimise la façon dont il affiche l’application pour la densité d’écran de chaque périphérique.

Par exemple, supposez que vous spécifiez une valeur PPP cible de 160 et activez le redimensionnement automatique. Lorsque vous exécutez l’application sur un périphérique doté d’une valeur PPP de 320, Flex redimensionne automatiquement l’application par un facteur 2. En d’autres termes, Flex agrandit tout de 200 %.

Pour spécifier la valeur PPP cible, définissez-la comme propriété

<s:ViewNavigatorApplication> ou <s:TabbedViewNavigatorApplication> dans le fichier de l’application

principale :

<s:ViewNavigatorApplication xmlns:fx="http://ns.adobe.com/mxml/2009"

xmlns:s="library://ns.adobe.com/flex/spark" firstView="views.HomeView" applicationDPI="160">

Si vous choisissez de ne pas utiliser le redimensionnement automatique de votre application, vous devez gérer manuellement les changements de densité pour votre présentation, selon les besoins. Toutefois, Flex adapte les habillages à la densité de chaque périphérique.

Pour plus d’informations à propos de la création d’applications mobiles indépendamment de la densité, voir « Prise

en charge de plusieurs tailles d’écran et valeurs PPP dans une application mobile » à la page 71.

applicationDPI de la balise

Connexion des périphériques Google Android

Vous pouvez connecter un périphérique Google Android à votre ordinateur de développement pour visualiser ou déboguer l’application sur le périphérique Android.

Périphériques Android pris en charge

Les projets mobiles Flex et les projets mobiles ActionScript requièrent AIR 2.6. Vous pouvez exécuter ou déboguer des projets mobiles seulement sur des périphériques physiques qui prennent en charge AIR 2.6. Vous pouvez installer AIR 2.6 sur des périphériques Android qui exécutent Android 2.2 ou version ultérieure.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

Configuration de périphériques Android

Pour exécuter et déboguer les applications Flex mobiles à partir d’un périphérique Android, activez le débogage USB comme indiqué ci-dessous :

1 Sur le périphérique, procédez comme suit pour vous assurer que le débogage USB est activé :

a Appuyez sur le bouton Accueil pour afficher l’écran d’accueil.

b Accédez à Paramètres, puis sélectionnez Applications > Développement.

c Activez le débogage USB.

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

3 Etendez vers le bas la zone de notification située en haut de l’écran. Vous devez voir une indication de type USB

connecté ou Connexion USB.

a Appuyez sur USB connecté ou sur Connexion USB.

b Si un ensemble d’options apparaît, parmi lesquelles le mode Charge seulement, sélectionnez le mode Charge

seulement et appuyez sur OK.

c Si vous voyez un bouton permettant de désactiver le mode stockage de masse, cliquez dessus pour désactiver le

stockage de masse.

4 (Windows uniquement) Installez le pilote USB approprié à votre périphérique. Voir « Installation de pilotes de

périphérique USB pour les périphériques Android (Windows) » à la page 16.

5 Etirez vers le bas la zone de notification situe en haut de l’écran.

Si le débogage USB n’apparaît pas parmi les entrées, vérifiez le mode USB comme décrit à l’étape 3 ci-dessus. Assurez-vous que le mode USB n’est pas défini sur Mode PC.

Remarque : une configuration supplémentaire est nécessaire pour le débogage. Voir « Exécution et débogage d’une

application mobile sur un périphérique » à la page 112.

Installation de pilotes de périphérique USB pour les périphériques Android (Windows)

Pilotes de périphérique et configurations

Les plateformes Windows requièrent l’installation d’un pilote USB pour connecter un périphérique Android à votre ordinateur de développement. Flash Builder fournit un pilote de périphérique et une configuration pour plusieurs périphériques Android.

Ces configurations de pilotes de périphérique sont répertoriées dans le fichier Device Manager accède à ce fichier au cours de l’installation du pilote de périphérique. Flash Builder installe

android_winusb.inf à l’emplacement suivant :

<Adobe Flash Builder 4.5 Home>\utilities\drivers\android\android_winusb.inf

Pour obtenir la liste complète des périphériques pris en charge, voir Périphériques certifiés. Dans le cas de périphériques Android ne figurant pas dans la liste, vous pouvez mettre à jour le fichier ajouter les pilotes USB. Voir « Ajout de configurations de pilotes de périphérique USB Android » à la page 17.

Installation d’un pilote de périphérique USB

1 Connectez votre périphérique Android au port USB de votre ordinateur.

2 Accédez à l’emplacement suivant :

android_winusb.inf. Windows

android_winusb.inf afin d’y

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

<Flash Builder>/utilities/drivers/android/

Installez le pilote USB à l’aide de l’Assistant Ajout de nouveau matériel détecté de Windows ou du Gestionnaire de périphériques Windows.

Ajout de configurations de pilotes de périphérique USB Android

Si vous avez un périphérique Android pris en charge qui ne figure pas dans la section « Installation de pilotes de

périphérique USB pour les périphériques Android (Windows) » à la page 16, mettez à jour le fichier

android_winusb.inf pour inclure le périphérique.

1 Branchez le périphérique à un port USB de votre ordinateur. Windows vous indique que le pilote est introuvable.

2 A l’aide du Gestionnaire de périphériques Windows, ouvrez l’onglet Détails des propriétés du périphérique.

3 Sélectionnez la propriété ID de matériel pour afficher l’ID du matériel.

4 Ouvrez le fichier android_winusb.inf dans un éditeur de texte. Recherchez android_winusb.inf à

l’emplacement suivant :

<Adobe Flash Builder 4.5 Home>\utilities\drivers\android\android_winusb.inf

5 Notez les éléments qui apparaissent dans le fichier relatif à votre architecture : [Google.NTx86] ou

[Google.NTamd64]. Les listes contiennent un commentaire descriptif et une ou plusieurs lignes dotées de l’ID de

matériel, comme cela est illustré ici :

. . . [Google.NTx86] ; HTC Dream %CompositeAdbInterface% = USB_Install, USB\VID_0BB4&PID_0C02&MI_01 . . .

6 Copiez et collez un commentaire et une description de matériel. Pour le pilote de périphérique que vous souhaitez

ajouter, modifiez la liste comme suit :

a Pour le commentaire, indiquez le nom du périphérique.

b Remplacez l’ID de matériel par celui qui a été identifié à l’étape 3 ci-dessus.

Par exemple :

. . . [Google.NTx86] ; NEW ANDROID DEVICE %CompositeAdbInterface% = USB_Install, NEW HARDWARE ID . . .

7 Utilisez le gestionnaire de périphériques Windows pour installer le périphérique, comme décrit dans « Installation

de pilotes de périphérique USB pour les périphériques Android (Windows) » à la page 16 ci-dessus.

Au cours de l’installation, Windows affiche un avertissement indiquant que le pilote provient d’un éditeur inconnu. Toutefois, le pilote permet à Flash Builder d’accéder à votre périphérique.

Important : si Windows ne reconnaît toujours pas le périphérique, vous devez installer le pilote USB approprié disponible auprès du fabricant du périphérique. Voir la page relative aux fabricants de pilotes USB pour obtenir des liens vers les sites Web de plusieurs fabricants de périphériques depuis lesquels vous pouvez télécharger le pilote USB approprié pour votre périphérique.

Brent Arnold, expert Flex certifié par Adobe, partage ses astuces qui permettent à votre périphérique Android

d’être reconnu par Windows.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Environnement de développement

Connexion de périphériques Apple iOS

Vous pouvez connecter un périphérique Apple iOS à votre ordinateur de développement pour déboguer ou déployer l’application sur le périphérique iOS.

Périphériques iOS pris en charge

Flash Builder fournit des configurations de périphérique pour les périphériques Apple iPhone, iTouch et iPad.

Ouvrez la fenêtre Préférences et sélectionnez Flash Builder > Configuration des périphériques pour afficher les configurations de périphérique pour tous les périphériques Apple pris en charge.

Préparation à l’installation et au déploiement d’une application sur un périphérique iOS

Connectez-vous au site du Pôle de développement iOS à l’aide de votre ID de compte de développeur iPhone, puis procédez comme suit :

1 Créez un fichier de demande de signature de certificat. Ce fichier permet d’obtenir un certificat de développement

iPhone.

Pour plus d’informations, voir Génération d’une demande de signature de certificat.

2 Générez un certificat de développement Apple (extension de nom de fichier .cer) et un fichier de profil

d’approvisionnement (extension de fichier .mobileprovision). Suivez les instructions fournies dans le Pôle de développement iOS.

Lors de la création du profil d’approvisionnement, répertoriez les ID des périphériques sur lesquels vous souhaitez installer l’application.

Pour plus d’informations, voir la documentation Apple destinée aux développeurs.

3 Convertissez le certificat de développement Apple au format de certificat P12.

Pour plus d’informations sur la conversion du certificat de développement Apple au format de certificat P12, voir

Conversion d’un certificat de développement en fichier P12.

Dernière mise à jour le 8/7/2011

Chapitre 3 : Interface utilisateur et présentation

Présentation d’une application mobile

Utilisation des vues et des sections pour présenter une application mobile

Une application mobile comporte un ou plusieurs écrans, ou vues. Par exemple, une application mobile peut posséder trois vues :

1 Une vue d’accueil qui vous permet d’ajouter des coordonnées

2 Une vue de contacts contenant la liste des contacts existants

3 Une vue de recherche permettant d’effectuer des recherches dans votre liste de contacts

Application mobile simple

L’image suivante présente l’écran principal d’une application mobile simple créée dans Flex :

A. Contrôle ActionBar B. Zone de contenu

Cette figure présente les zones principales d’une application mobile :

Contrôle ActionBar Le contrôle ActionBar vous permet d’afficher des informations contextuelles à propos de l’état

actuel de l’application. Ces informations comprennent une zone de titre, une zone réservée aux contrôles permettant de naviguer dans l’application et une zone réservée aux contrôles permettant de réaliser une action. Vous pouvez ajouter un contenu commun dans le contrôle ActionBar qui s’applique à l’ensemble de l’application, et vous pouvez ajouter des éléments spécifiques à une vue individuelle.

Zone de contenu La zone de contenu affiche les écrans individuels, ou vues, qui constituent l’application. Les

utilisateurs naviguent dans les vues de l’application en utilisant les composants intégrés à l’application et les contrôles d’entrée du périphérique mobile.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Interface utilisateur et présentation

Une application mobile comprenant des sections

Une application plus complexe pourrait définir plusieurs zones, ou sections, de l’application. Par exemple, l’application pourrait comprendre une section contacts, une section e-mail, une section favoris et d’autres sections. Chaque section de l’application contient une ou plusieurs vues. Les vues individuelles peuvent être partagées entre les sections, ce qui vous évite d’avoir à définir la même vue à plusieurs reprises.

La figure ci-dessous présente une application mobile qui inclut une barre d’onglets au bas de la fenêtre de l’application :

A. Contrôle ActionBarB. Zone de contenuC. Barre d’onglets

Flex utilise le contrôle ButtonBarBase pour implémenter la barre d’onglets. Chaque bouton de la barre d’onglets correspond à une section différente. Sélectionnez un bouton dans la barre d’onglets pour modifier la section actuelle.

Chaque section de l’application définit son propre contrôle ActionBar. Par conséquent, la barre d’onglets est commune à l’ensemble de l’application, alors que le contrôle ActionBar est spécifique à chaque section.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Interface utilisateur et présentation

Présentation d’une application mobile simple

La figure suivante présente l’architecture d’une application mobile simple :

Main application (ViewNavigatorApplication)

(ViewNavigator)

Home (View)

Contacts (View)

Search (View)

La figure présente une application composée de quatre fichiers. Une application mobile contient un fichier de l’application principale et un fichier pour chaque vue. Il n’existe pas de fichier distinct pour le conteneur ViewNavigator. Le conteneur ViewNavigatorApplication le crée.

Remarque : ce schéma présente l’architecture de l’application, mais ne représente pas l’application en cours d’exécution. Lors de l’exécution, une seule vue est active et résidente dans la mémoire. Pour plus d’informations, voir « Navigation

parmi les vues d’une application mobile » à la page 23.

Classes utilisées dans une application mobile

Utilisez les classes suivantes pour définir une application mobile :

Classe Description

ViewNavigatorApplicationDéfinit le fichier de l’application principale. Le conteneur ViewNavigatorApplication n’accepte

ViewNavigator Contrôle la navigation parmi les vues d’une application. Le conteneur ViewNavigator crée

Vue Définit les vues de l’application, chaque vue étant définie dans un fichier MXML ou ActionScript

pas d’enfants.

également le contrôle ActionBar.

Le conteneur ViewNavigatorApplication crée automatiquement un seul conteneur ViewNavigator pour l’ensemble de l’application. Utilisez les méthodes du conteneur ViewNavigator pour basculer entre les différentes vues.

distinct. Une instance du conteneur View représente chaque vue de l’application. Définissez chaque vue dans un fichier MXML ou ActionScript distinct.

Utilisez le conteneur ViewNavigatorApplication pour définir le fichier d’application principal, comme l’illustre l’exemple suivant :

<?xml version="1.0" encoding="utf-8"?>  <s:ViewNavigatorApplication xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" firstView="views.HomeView"> </s:ViewNavigatorApplication>

Le conteneur ViewNavigatorApplication crée automatiquement un seul objet ViewNavigator qui définit le contrôle ActionBar. Vous utilisez le conteneur ViewNavigator pour naviguer parmi les vues de l’application.

Ajout d’un conteneur View à une application mobile

Chaque application mobile comporte au moins une vue. Même si le fichier de l’application principale crée le conteneur ViewNavigator, il ne définit aucune des vues utilisées dans l’application.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Interface utilisateur et présentation

Chaque vue d’une application correspond à un conteneur View défini dans un fichier ActionScript ou MXML. Chaque vue contient une propriété

data pour échanger des informations entre elles tandis que l’utilisateur navigue dans l’application.

data qui spécifie les données associées à cette vue. Les vues peuvent utiliser la propriété

Utilisez la propriété l’application. Dans l’application précédente, la propriété

ViewNavigatorApplication.firstView pour spécifier le fichier qui définit la première vue de

firstView spécifie views.HomeView. L’exemple suivant

présente le fichier HomeView.mxml qui définit cette vue :

<?xml version="1.0" encoding="utf-8"?>  <s:View xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" title="Home"> <s:layout> <s:VerticalLayout paddingTop="10"/> </s:layout> <s:Label text="The home screen"/> </s:View>

Le blogueur David Hassoun a communiqué sur les bases de ViewNavigator.

Présentation d’une application mobile comprenant plusieurs sections.

Une application mobile peut collecter des vues associées dans différentes sections de l’application. Par exemple, la figure suivante présente l’organisation d’une application mobile comprenant trois sections.

Main application (TabbedViewNavigatorApplication)

(TabbedViewNavigator)

Contacts (ViewNavigator)

Contacts Home (View)

Edit Contacts (View)

Search (View)

Email (ViewNavigator)

Email Home (View)

Edit Contacts (View)

Search (View)

Favorites (ViewNavigator)

Favorites Home (View)

Search (View)

N’importe quelle section peut utiliser n’importe quelle vue. En d’autres termes, une vue n’appartient pas à une section particulière. La section définit simplement une manière d’organiser un ensemble de vues et de naviguer parmi elles. Dans la figure, la vue Search fait partie de chaque section de l’application.

Au moment de l’exécution, une seule vue est active et résidente dans la mémoire. Pour plus d’informations, voir « Navigation parmi les vues d’une application mobile » à la page 23.

Classes utilisées dans une application mobile comprenant plusieurs sections

Le tableau suivant répertorie les classes que vous utilisez pour créer une application mobile comprenant plusieurs sections :

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Interface utilisateur et présentation

Classe Description

TabbedViewNavigatorApplication Définit le fichier d’application principal. Le seul enfant autorisé du conteneur

TabbedViewNavigator Contrôle la navigation parmi les sections qui constituent l’application.

ViewNavigator Définissez un conteneur ViewNavigator pour chaque section. Le conteneur

Vue Définit les vues de l’application. Une instance du conteneur View représente chaque vue

TabbedViewNavigatorApplication est ViewNavigator. Définissez un conteneur ViewNavigator pour chaque section de l’application.

Le conteneur TabbedViewNavigatorApplication crée automatiquement un seul conteneur TabbedViewNavigator pour l’ensemble de l’application. Le conteneur TabbedViewNavigator crée la barre d’onglets que vous utilisez pour naviguer parmi les sections.

ViewNavigator contrôle la navigation parmi les vues qui constituent la section. Il crée également le contrôle Actionbar pour la section.

de l’application. Définissez chaque vue dans un fichier MXML ou ActionScript distinct.

Une application mobile divisée en plusieurs sections contient un fichier de l’application principale et un fichier qui définit chacune des vues. Utilisez le conteneur TabbedViewNavigatorApplication pour définir le fichier d’application principal, comme l’illustre l’exemple suivant :

<?xml version="1.0" encoding="utf-8"?>  <s:TabbedViewNavigatorApplication xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark"> <s:ViewNavigator label="Contacts" firstView="views.ContactsHome"/> <s:ViewNavigator label="Email" firstView="views.EmailHome"/> <s:ViewNavigator label="Favorites" firstView="views.FavoritesHome"/> </s:TabbedViewNavigatorApplication>

Utilisation de ViewNavigator dans une application à plusieurs sections

Le seul composant enfant accepté pour le conteneur TabbedViewNavigatorApplication est ViewNavigator. Chaque section de l’application correspond à un conteneur ViewNavigator différent.

Utilisez le conteneur ViewNavigator pour naviguer parmi les vues de chaque section et pour définir le contrôle ActionBar pour la section. Utilisez la propriété

ViewNavigator.firstView pour spécifier le fichier qui définit la

première vue de la section.

Utilisation de TabbedViewNavigator dans une application à plusieurs sections

Le conteneur TabbedViewNavigatorApplication crée automatiquement un seul conteneur de type TabbedViewNavigator. Le conteneur TabbedViewNavigator crée alors une barre d’onglets au bas de l’application. Vous n’êtes pas tenu d’ajouter une logique à l’application pour naviguer parmi les sections.

Navigation parmi les vues d’une application mobile

Une pile d’objets View contrôle la navigation dans une application mobile. L’objet View supérieur de la pile définit la vue actuellement visible.

Le conteneur ViewNavigator gère la pile. Pour changer de vue, poussez un nouvel objet View sur la pile ou retirez l’objet View actuel de la pile. Le fait de retirer de la pile l’objet View actuellement visible détruit l’objet View et ramène l’utilisateur à la vue précédente sur la pile.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Interface utilisateur et présentation

Dans une application dotée de sections, utilisez la barre d’onglets pour naviguer parmi les sections. Comme un conteneur ViewNavigator différent définit chaque section, changer de section revient à changer le conteneur ViewNavigator et la pile actuels. L’objet View situé au sommet de la pile du nouveau conteneur ViewNavigator devient la vue actuelle.

Pour économiser la mémoire, par défaut, le conteneur ViewNavigator s’assure qu’une seule vue est en mémoire à la fois. Toutefois, il conserve les données des vues précédentes de la pile. Par conséquent, lorsque l’utilisateur revient à la vue précédente, celle-ci peut être réinstanciée avec les données appropriées.

Remarque : le conteneur View définit la propriété conteneur ViewNavigator détruit la vue lorsqu’elle n’est pas active. S’il est défini sur

destructionPolicy. S’il est défini sur auto, la valeur par défaut, le

none, la vue est mise en mémoire

cache.

Le blogueur Mark Lochrie a communiqué sur Flash Builder 4.5 ViewNavigator.

Méthodes de navigation ViewNavigator

Utilisez les méthodes suivantes de la classe ViewNavigator pour contrôler la navigation :

pushView() Poussez un objet View sur la pile. L’objet View communiqué en tant qu’argument à la méthode

pushView() devient la vue actuelle.

popView() Retirez l’objet View actuel de la pile de navigation et détruisez l’objet View. L’objet View précédent sur la

pile devient la vue actuelle.

popToFirstView() Retirez tous les objets View de la pile et détruisez-les, à l’exception du premier objet View de la pile.

Le premier objet View de la pile devient la vue actuelle.

popAll()

Videz la pile du conteneur ViewNavigator et détruisez tous les objets View. Votre application affiche une vue vide.

La figure suivante présente deux vues. Pour changer la vue actuelle, utilisez la méthode ViewNavigator.pushView() pour pousser un objet View qui représente la nouvelle vue sur la pile. La méthode

pushView() invite le conteneur

ViewNavigator à basculer l’affichage vers le nouvel objet View.

Installation et élimination d’objets View pour changer de vue.

Utilisez la méthode ViewNavigator.popView() pour éliminer l’objet View actuel de la pile. Le conteneur ViewNavigator ramène l’affichage à l’objet View précédent sur la pile.

Remarque : le périphérique mobile lui-même contrôle en grande partie la navigation dans une application mobile. Par exemple, les applications mobiles intégrées à Flex gèrent automatiquement le bouton retour sur les périphériques mobiles. Par conséquent, vous n’avez pas à ajouter la prise en charge du bouton retour dans l’application. Lorsque l’utilisateur appuie sur le bouton retour du périphérique mobile, Flex appelle automatiquement la méthode

popView() pour

restaurer la vue précédente.

Le blogueur David Hassoun a communiqué surla gestion des données dans une vue.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Interface utilisateur et présentation

Définition de la navigation pour une application à plusieurs sections

Dans la figure suivante, les vues sont organisées en plusieurs sections. Un conteneur ViewNavigator différent définit chaque section. Chaque section contient une ou plusieurs vues :

A. ActionBar B. Zone de contenu C. Barre d’onglets

Pour modifier la vue dans la section en cours, qui correspond au conteneur ViewNavigator actuel, utilisez les méthodes

pushView() et popView().

Pour modifier la section actuelle, utilisez la barre d’onglets. Lorsque vous changez de section, vous basculez vers le conteneur ViewNavigator de la nouvelle section. L’affichage change et présente l’objet View qui se trouve actuellement au-dessus de la pile du nouveau ViewNavigator.

Vous pouvez aussi programmer le changement de section à l’aide de la propriété

TabbedViewNavigator.selectedIndex. Cette propriété contient l’index de base 0 du navigateur de vues

sélectionné.

Dernière mise à jour le 8/7/2011

DÉVELOPPEMENT D’APPLICATIONS MOBILES AVEC FLEX ET FLASH BUILDER

Interface utilisateur et présentation

Gestion des saisies de l’utilisateur dans une application mobile

La saisie utilisateur requiert une gestion différente dans une application mobile par rapport à une application de bureau ou de navigateur. Dans une application de bureau créée pour AIR ou dans une application de navigateur conçue pour Flash Player, les principaux dispositifs de saisie sont une souris et un clavier. Dans le cas de périphériques mobiles, le dispositif de série principal est un écran tactile. Un périphérique mobile possède souvent un type de clavier et certains périphériques disposent également d’une méthode de saisie à cinq directions (gauche, droite, haut, bas et sélection).

La classe mx.core.UIComponent définit la propriété de style composants pour le type de saisie utilisé par l’application. Pour les thèmes Halo et Spark, la valeur par défaut est ce qui indique que la souris est le dispositif de saisie principal. Pour le thème Mobile, la valeur par défaut est

interactionMode que vous utilisez pour configurer des

mouse,

touch, ce

qui indique que l’écran tactile constitue le dispositif de saisie principal.

Prise en charge des touches du matériel

Les applications définies par les conteneurs ViewNavigatorApplication ou TabbedViewNavigatorApplication répondent aux touches matérielles Retour et Menu d’un périphérique. Lorsque l’utilisateur appuie sur la touche Retour, l’application revient à la vue précédente. S’il n’y a pas de vue précédente, l’application se ferme et l’écran d’accueil du périphérique apparaît.

Lorsque l’utilisateur appuie sur le bouton Retour, la vue active de l’application reçoit un événement Vous pouvez annuler l’action de la touche Retour en appelant pour l’événement

backKeyPressed.

preventDefault() dans le gestionnaire d’événement

Lorsque l’utilisateur appuie sur le bouton Menu, le conteneur ViewMenu de la vue actuelle apparaît, s’il est défini. Le conteneur ViewMenu définit un menu situé au bas du conteneur View. Chaque conteneur View définit son propre menu, spécifique à cette vue.

Le contrôle View actif envoie un événement

menuKeyPressed lorsque l’utilisateur appuie sur la touche Menu. Pour

annuler l’action du bouton Menu et empêcher l’affichage de ViewMenu, appelez la méthode le gestionnaire d’événement pour l’événement

menuKeyPressed.

Pour plus d’informations, voir « Définition de menus dans une application mobile » à la page 53.

backKeyPressed.

preventDefault() dans

Gestion des événements de souris et tactiles dans une application mobile

AIR génère différents événements pour indiquer différents types de saisie. Ces événements comprennent :

Evénements de souris Evénements générés par une intervention de l’utilisateur effectuée au moyen d’une souris ou

d’un écran tactile. Les événements de souris comprennent

Evénements tactiles Evénements générés sur des périphériques qui détectent les contacts de l’utilisateur avec le

périphérique, par exemple le contact d’un doigt sur un écran tactile. Les événements tactiles comprennent

touchOver et touchMove. Lorsqu’un utilisateur utilise un périphérique équipé d’un écran tactile, il touche

généralement l’écran du doigt ou à l’aide d’un dispositif de pointage.

Evénements de mouvement Evénements générés par des interactions tactiles multipoint, telles que la pression de

deux doigts simultanément sur un écran tactile. Les événements de mouvement comprennent

gestureRotate et gestureZoom. Par exemple, sur certains périphériques, il est possible d’effectuer un geste de

pincement pour produire un zoom arrière dans une image.

Prise en charge intégrée des événements de souris

Dernière mise à jour le 8/7/2011

mouseOver, mouseDown et mouseUp.

touchTap,

gesturePan,

+ 98 hidden pages