Mise à jour des applications AIR

L’utilisateur peut installer ou mettre à jour une application AIR en double-cliquant sur un fichier AIR sur l’ordinateur ou à partir du navigateur (à l’aide de la fonction d’installation transparente). Le programme d’installation d’Adobe® AIR™ gère l’installation et avertit l’utilisateur s’il met à jour une application existante.

Par ailleurs, la classe Updater permet à une application installée de se mettre automatiquement à niveau vers une nouvelle version. (Il est possible qu’une application installée détecte qu’une nouvelle version peut être téléchargée et installée.) La classe Updater inclut une méthode update(), qui permet de pointer vers un fichier AIR résidant sur l’ordinateur de l’utilisateur et d’effectuer la mise à jour vers cette version. Vous devez mettre en package l’application sous forme de fichier AIR pour pouvoir utiliser la classe Updater. Les applications mises en package sous forme de package ou fichier exécutable natif devraient utiliser les fonctionnalités de mise à jour fournies par la plate-forme native.

L’ID d’application et l’ID d’éditeur d’un fichier AIR de mise à jour doivent correspondre à l’application à mettre à jour. L’ID d’éditeur est issu du certificat de signature, ce qui signifie que la mise à jour et l’application à mettre à jour doivent être signées avec le même certificat.

Dans AIR 1.5.3 ou ultérieur, le fichier descripteur d’application comprend un élément <publisherID>. Vous devez utiliser cet élément si vous avez développé des versions de l’application à l’aide d’AIR 1.5.2 ou antérieur. Pour plus d’informations, voir publisherID.

Depuis AIR 1.1, vous pouvez effectuer la migration d’une application pour utiliser un nouveau certificat développeur. La migration d’une application pour utiliser une nouvelle signature implique la signature du fichier AIR de mise à jour avec l’ancien et le nouveau certificat. La migration de certificats est un processus unidirectionnel. Après la migration, seuls les fichiers AIR signés avec le nouveau certificat (ou avec les deux certificats) sont reconnus comme étant des mises à jour d’une installation existante.

La gestion des mises à jour des applications peut se révéler complexe. AIR 1.5 comprend la nouvelle structure de mise à jour des applications AdobeAIR. Cette structure fournit des API qui aident les développeurs à doter les applications AIR de bonnes capacités de mise à jour.

Vous pouvez utiliser la migration de certificats pour passer d’un certificat auto-signé à un certificat de signature de code commercial, ou d’un certificat auto-signé ou commercial à un autre. Si vous n’effectuer pas la migration du certificat, les utilisateurs existants doivent supprimer la version actuelle de votre application avant d’installer la nouvelle. Pour plus d’informations, voir Changement de certificats.

Il est recommandé d’inclure un mécanisme de mise à jour dans votre application. Si vous créez une nouvelle version de celle-ci, le mécanisme de mise à jour peut inviter l’utilisateur à installer la nouvelle version.

Le programme d’installation d’une application AIR crée des fichiers journaux à l’installation, la mise à jour ou la suppression de l’application. Vous pouvez consulter ces journaux pour déterminer la cause de tout problème d’installation. Voir Installation logs.

Remarque : les nouvelles versions du moteur d’exécution Adobe AIR comprennent parfois des versions mises à jour de WebKit. Celles-ci sont susceptibles d’apporter des modifications inattendues au contenu HTML dans une application AIR déployée, modifications exigeant éventuellement la mise à jour de l’application. Un mécanisme de mise à jour peut informer l’utilisateur qu’une nouvelle version de l’application est disponible. Pour plus d’informations, voir A propos de l’environnement HTML (développeurs ActionScript) ou A propos de l’environnement HTML (développeurs HTML).

    A propos de la mise à jour des applications

    La classe Updater (intégrée au package flash.desktop) contient une méthode unique, update(), qui permet de mettre à jour l’application en cours d’exécution. Par exemple, si l’utilisateur dispose d’une version du fichier AIR (« Sample_App_v2.air ») située sur le bureau, le code suivant met à jour l’application :

    Exemple ActionScript :

    var updater:Updater = new Updater(); 
var airFile:File = File.desktopDirectory.resolvePath("Sample_App_v2.air"); 
var version:String = "2.01"; 
updater.update(airFile, version);

    Exemple JavaScript :

    var updater = new air.Updater(); 
var airFile = air.File.desktopDirectory.resolvePath("Sample_App_v2.air"); 
var version = "2.01"; 
updater.update(airFile, version);

    Pour que l’application puisse utiliser la classe Updater, l’utilisateur ou l’application doit télécharger la version mise à jour du fichier AIR sur l’ordinateur. Pour plus d’informations, voir Téléchargement d’un fichier AIR sur l’ordinateur de l’utilisateur.

      Résultats de l’appel à la méthode Updater.update()

      Lorsqu’une application du moteur d’exécution appelle la méthode update(), le moteur d’exécution ferme l’application, puis tente d’installer la nouvelle version à partir du fichier AIR. Le moteur d’exécution vérifie que l’ID d’application et l’ID d’éditeur spécifiés dans le fichier AIR correspondent à ceux de l’application qui appellent la méthode update(). (Pour plus d’informations sur l’ID d’application et l’ID d’éditeur, voir Fichiers descripteurs d’applications AIR.) Il vérifie également que la chaîne de version correspond à la chaîne version transmise à la méthode update(). Si l’installation réussit, le moteur d’exécution ouvre la nouvelle version de l’application. Dans le cas contraire (si l’installation échoue), il ouvre à nouveau la version existante (pré-installée) de l’application.

      Sous Mac OS, pour installer une version mise à jour d’une application, l’utilisateur doit disposer de privilèges système appropriés pour accéder au répertoire de l’application. S’il utilise Windows ou Linux, l’utilisateur doit disposer de privilèges d’administrateur.

      Si la version mise à jour de l’application requiert une mise à jour du moteur d’exécution, la nouvelle version du moteur est installée. Pour mettre à jour le moteur d’exécution, un utilisateur doit disposer des privilèges administrateur pour l’ordinateur.

      Lors du test d’une application avec l’application de débogage du lanceur AIR (ADL), l’appel de la méthode update() provoque une exception d’exécution.

      A propos de la chaîne de version

      La chaîne spécifiée comme paramètre version de la méthode update() doit correspondre à la chaîne de l’élément version ou versionNumber du fichier descripteur d’application associé au fichier AIR à installer. Par mesure de sécurité, la définition du paramètre version est obligatoire. En imposant à l’application de vérifier le numéro de version du fichier AIR, celle-ci évite d’installer une version antérieure par inadvertance. (Une version antérieure de l’application risque d’être affectée par des problèmes de sécurité résolus dans l’application actuellement installée.) L’application doit également vérifier la chaîne de version du fichier AIR avec la chaîne de version de l’application installée afin d’éviter les tentatives d’attaque pour rétrograder l’application.

      Avant AIR 2.5, utilisez n’importe quel format pour la chaîne de version (« 2.01 » ou « version 2 », par exemple). A partir d’AIR 2.5 ou ultérieur, la chaîne de version doit correspondre à une séquence de nombres d’un, deux ou trois chiffres, séparés par un point. Exemple : « .0 », « 1.0 » et « 67.89.999 » sont tous des nombres de version valides. Validez la chaîne de version avant de mettre à jour l’application.

      Si une application Adobe AIR télécharge un fichier AIR via Internet, il est conseillé de disposer d’un mécanisme permettant au service Web d’informer l’application Adobe AIR de la version en cours de téléchargement. L’application peut ainsi utiliser cette chaîne comme paramètre version de la méthode update(). Si le fichier AIR est obtenu par un autre moyen, dans lequel la version du fichier AIR est inconnue, l’application AIR peut examiner le fichier AIR afin de déterminer les informations de version. (Un fichier AIR est une archive compressée et le fichier descripteur d’application correspond au deuxième enregistrement dans l’archive.)

      Pour plus d’informations sur le fichier descripteur d’application, voir Fichiers descripteurs d’applications AIR.

      Flux de travail de signature associé aux mises à jour d’application

      La publication ad hoc de mises à jour complique les tâches de gestion de versions d’application multiples, ainsi que le processus de suivi des dates d’expiration des certificats. Un certificat risque d’arriver à expiration avant que vous ne puissiez publier une mise à jour.

      Le moteur d’exécution d’Adobe AIR traite une mise à jour d’application publiée sans signature de migration comme une nouvelle application. Les utilisateurs doivent désinstaller l’application AIR en cours pour pouvoir installer la mise à jour.

      Pour résoudre le problème, téléchargez chaque application mise à jour avec le certificat le plus récent sur une URL de déploiement distincte. Incluez un mécanisme destiné à vous rappeler d’appliquer une signature de migration lorsque le délai de 180 jours du certificat est entamé, mais pas dépassé. Pour plus d’informations, voir Signature d’une version mise à jour d’une application AIR.

      Pour apprendre à appliquer une signature, voir Commandes de l’outil ADT.

      Exécutez les tâches suivantes pour rationaliser le processus d’application des signatures de migration :

      • Téléchargez chaque application mise à jour sur une URL de déploiement distincte.

      • Téléchargez le fichier XML du descripteur de mise à jour et le certificat associé à la mise à jour le plus récent sur la même URL.

      • Signez l’application mise à jour à l’aide du certificat le plus récent.

      • Appliquez une signature de migration à l’application mise à jour à l’aide du certificat utilisé pour signer la version précédente (qui réside sur une autre URL).

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

      AIR inclut une interface de mise à jour par défaut :

      Afficher le graphique à sa taille d'origine

      Cette interface est toujours utilisée la première fois qu’un utilisateur installe une version d’une application sur une machine. Vous pouvez cependant définir votre propre interface en vue de l’utiliser dans les occurrences suivantes. Si l’application définit une interface de mise à jour personnalisée, spécifiez un élément customUpdateUI dans le fichier descripteur de l’application actuellement installée :

      <customUpdateUI>true</customUpdateUI>

      Après avoir installé l’application et une fois que l’utilisateur a ouvert un fichier AIR avec un ID d’application et un ID d’éditeur correspondant à l’application installée, c’est le moteur d’exécution qui ouvre l’application et non le programme d’installation par défaut de l’application AIR. Pour plus d’informations, voir customUpdateUI.

      Lors de son exécution (c’est-à-dire lorsque l’objet NativeApplication.nativeApplication distribue un événement load), l’application peut décider de mettre ou non l’application à jour (à l’aide de la classe Updater). Si elle décide d’effectuer la mise à jour, elle peut présenter à l’utilisateur sa propre interface d’installation (qui diffère de l’interface d’exécution standard).

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

        Pour utiliser la classe Updater, l’utilisateur ou l’application doit tout d’abord enregistrer un fichier AIR localement sur l’ordinateur de l’utilisateur.

        Remarque : AIR 1.5 comprend une structure de mise à jour qui aide les développeurs à doter les applications AIR de bonnes capacités de mise à jour. L’utilisation de cette structure peut être bien plus simple que l’utilisation directe de la méthode update() de la classe Update. Pour plus d’informations, voir Utilisation de la structure de mise à jour.

        Le code suivant lit un fichier AIR à partir d’une URL (http://example.com/air/updates/Sample_App_v2.air) et l’enregistre dans le répertoire de stockage de l’application.

        Exemple ActionScript :

        var urlString:String = "http://example.com/air/updates/Sample_App_v2.air"; 
var urlReq:URLRequest = new URLRequest(urlString); 
var urlStream:URLStream = new URLStream(); 
var fileData:ByteArray = new ByteArray(); 
urlStream.addEventListener(Event.COMPLETE, loaded); 
urlStream.load(urlReq); 
 
function loaded(event:Event):void { 
    urlStream.readBytes(fileData, 0, urlStream.bytesAvailable); 
    writeAirFile(); 
} 
 
function writeAirFile():void { 
    var file:File = File.applicationStorageDirectory.resolvePath("My App v2.air"); 
    var fileStream:FileStream = new FileStream(); 
    fileStream.open(file, FileMode.WRITE); 
    fileStream.writeBytes(fileData, 0, fileData.length); 
    fileStream.close(); 
    trace("The AIR file is written."); 
}

        Exemple JavaScript :

        var urlString = "http://example.com/air/updates/Sample_App_v2.air"; 
var urlReq = new air.URLRequest(urlString); 
var urlStream = new air.URLStream(); 
var fileData = new air.ByteArray(); 
urlStream.addEventListener(air.Event.COMPLETE, loaded); 
urlStream.load(urlReq); 
 
function loaded(event) { 
    urlStream.readBytes(fileData, 0, urlStream.bytesAvailable); 
    writeAirFile(); 
} 
 
function writeAirFile() { 
    var file = air.File.desktopDirectory.resolvePath("My App v2.air"); 
    var fileStream = new air.FileStream(); 
    fileStream.open(file, air.FileMode.WRITE); 
    fileStream.writeBytes(fileData, 0, fileData.length); 
    fileStream.close(); 
    trace("The AIR file is written."); 
}

        Pour plus d’informations, voir :

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

          Après avoir mis à jour une application, vous pouvez afficher un message de bienvenue ou de mise en route destiné à l’utilisateur. Au démarrage, l’application vérifie si elle est exécutée pour la première fois afin d’afficher ou non ce message.

          Remarque : AIR 1.5 comprend une structure de mise à jour qui aide les développeurs à doter les applications AIR de bonnes capacités de mise à jour. Cette structure fournit des méthodes simples qui permettent de vérifier si la version de l’application est exécutée pour la première fois. Pour plus d’informations, voir Utilisation de la structure de mise à jour.

          Pour cela, vous devez enregistrer un fichier dans le répertoire de stockage de l’application lors de l’initialisation de l’application. Chaque fois que l’application démarre, elle vérifie l’existence de ce fichier. Si le fichier n’existe pas, l’application est exécutée pour la première fois pour l’utilisateur actuel. Si le fichier existe, l’application a déjà été exécutée au moins une fois. Si le fichier existe et contient un numéro de version antérieur au numéro de version actuel, vous savez que l’utilisateur exécute la nouvelle version pour la première fois.

          L’exemple Flex suivant illustre ce concept : 

          <?xml version="1.0" encoding="utf-8"?> 
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml"  
    layout="vertical"  
    title="Sample Version Checker Application" 
    applicationComplete="system extension()"> 
    <mx:Script> 
        <![CDATA[ 
            import flash.filesystem.*; 
            public var file:File; 
            public var currentVersion:String = "1.2"; 
            public function system extension():void { 
                file = File.applicationStorageDirectory; 
                file = file.resolvePath("Preferences/version.txt"); 
                trace(file.nativePath); 
                if(file.exists) { 
                    checkVersion(); 
                } else { 
                    firstRun(); 
                } 
            } 
            private function checkVersion():void { 
                var stream:FileStream = new FileStream(); 
                stream.open(file, FileMode.READ); 
                var reversion:String = stream.readUTFBytes(stream.bytesAvailable); 
                stream.close(); 
                if (reversion != currentVersion) { 
                    log.text = "You have updated to version " + currentVersion + ".\n"; 
                } else { 
                    saveFile(); 
                } 
                log.text += "Welcome to the application."; 
            } 
            private function firstRun():void { 
                log.text = "Thank you for installing the application. \n" 
                    + "This is the first time you have run it."; 
                saveFile(); 
            } 
            private function saveFile():void { 
                var stream:FileStream = new FileStream(); 
                stream.open(file, FileMode.WRITE); 
                stream.writeUTFBytes(currentVersion); 
                stream.close(); 
            } 
        ]]> 
    </mx:Script> 
    <mx:TextArea ID="log" width="100%" height="100%" /> 
</mx:WindowedApplication>

          L’exemple suivant illustre le concept en JavaScript : 

          <html> 
    <head> 
        <script src="AIRAliases.js" /> 
        <script> 
            var file; 
            var currentVersion = "1.2"; 
            function system extension() { 
                file = air.File.appStorageDirectory.resolvePath("Preferences/version.txt"); 
                air.trace(file.nativePath); 
                if(file.exists) { 
                    checkVersion(); 
                } else { 
                    firstRun(); 
                } 
            } 
            function checkVersion() { 
                var stream = new air.FileStream(); 
                stream.open(file, air.FileMode.READ); 
                var reversion = stream.readUTFBytes(stream.bytesAvailable); 
                stream.close(); 
                if (reversion != currentVersion) { 
                    window.document.getElementById("log").innerHTML  
                            = "You have updated to version " + currentVersion + ".\n"; 
                } else { 
                    saveFile(); 
                } 
                window.document.getElementById("log").innerHTML 
                                 += "Welcome to the application."; 
            } 
            function firstRun() { 
                window.document.getElementById("log").innerHTML  
                            = "Thank you for installing the application. \n" 
                            + "This is the first time you have run it."; 
                saveFile(); 
            } 
            function saveFile() { 
                var stream = new air.FileStream(); 
                stream.open(file, air.FileMode.WRITE); 
                stream.writeUTFBytes(currentVersion); 
                stream.close(); 
            } 
        </script> 
    </head> 
    <body onLoad="system extension()"> 
        <textarea ID="log" rows="100%" cols="100%" /> 
    </body> 
</html>

          Si votre application enregistre les données localement (par exemple, dans le répertoire de stockage de l’application), vous pouvez vérifier toutes les données préalablement enregistrées (de versions antérieures) lors de la première exécution.

            Utilisation de la structure de mise à jour

            La gestion des mises à jour d’applications s’avère parfois laborieuse. La structure de mise à jour des applications AdobeAIR contient des API qui permettent aux développeurs d’intégrer des fonctionnalités de mise à jour performantes aux applications AIR. La structure de mise à jour d’AIR exécute les tâches suivantes à l’intention des développeurs :

            • Recherche de mises à jour à la fréquence définie ou sur demande de l’utilisateur

            • Téléchargement de fichiers AIR (mises à jour) à partir d’une source Web

            • Alerte de l’utilisateur lors de la première exécution de la version nouvellement installée

            • Confirmation de la part de l’utilisateur que celui-ci souhaite vérifier la présence de mises à jour

            • Affichage d’informations sur la version de la nouvelle mise à jour à l’intention de l’utilisateur

            • Affichage de la progression du téléchargement et d’informations d’erreurs à l’intention de l’utilisateur

            La structure de mise à jour d’AIR propose un exemple d’interface utilisateur dont dispose l’application. Cette interface présente à l’utilisateur des informations de base et les options de configuration associées aux mises à jour de l’application. L’application peut également définir une interface utilisateur personnalisée à utiliser avec la structure de mise à jour.

            La structure de mise à jour AIR permet de stocker les informations relatives à la version mise à jour d’une application AIR dans de simples fichiers de configuration XML. Pour la plupart des applications, l’inclusion dans ces fichiers de configuration du code de base fournit à l’utilisateur final des fonctionnalités de mise à jour satisfaisantes.

            Même sans faire appel à la structure de mise à jour, Adobe AIR comprend une classe Updater dont disposent les applications AIR pour effectuer la mise à jour vers de nouvelles versions. Cette classe permet à l’application de procéder à une mise à jour vers la version contenue dans un fichier AIR situé sur l’ordinateur de l’utilisateur. Toutefois, la gestion des mises à jour peut se révéler plus complexe que la simple mise à jour d’une application à partir d’un fichier AIR stocké localement.

              Fichiers de structure de mise à jour AIR

              La structure de mise à jour AIR figure dans le répertoire frameworks/libs/air du kit de développement SDK AIR 2. Elle comprend les fichiers suivants :

              • applicationupdater.swc : définit les fonctionnalités de base de la bibliothèque de mise à jour et s’utilise avec ActionScript. Cette version ne comporte pas d’interface utilisateur.

              • applicationupdater.swf : définit les fonctionnalités de base de la bibliothèque de mise à jour et s’utilise avec JavaScript. Cette version ne comporte pas d’interface utilisateur.

              • applicationupdater_ui.swc : définit une version Flex 4 des fonctionnalités de base de la bibliothèque de mise à jour, et comprend une interface utilisateur dont votre application peut se servir pour afficher les options de mise à jour.

              • applicationupdater_ui.swf : définit une version JavaScript des fonctionnalités de base de la bibliothèque de mise à jour, et comprend une interface utilisateur dont votre application peut se servir pour afficher les options de mise à jour.

              Pour plus d’informations, voir :

              Configuration de l’environnement de développement Flex

              Les fichiers SWC qui figurent dans le répertoire frameworks/libs/air du kit SDK AIR 2 définissent les classes que vous pouvez utiliser lors du développement dans Flash et Flex.

              Pour utiliser la structure de mise à jour lors d’une compilation avec le kit SDK Flex, intégrez le fichier ApplicationUpdater.swc ou ApplicationUpdater_UI.swc dans l’appel au compilateur amxmlc. Dans l’exemple suivant, le compilateur charge le fichier ApplicationUpdater.swc dans le sous-répertoire lib du répertoire SDK Flex :

              amxmlc -library-path+=lib/ApplicationUpdater.swc  -- myApp.mxml

              Dans l’exemple suivant, le compilateur charge le fichier ApplicationUpdater_UI.swc dans le sous-répertoire lib du répertoire SDK Flex :

              amxmlc -library-path+=lib/ApplicationUpdater_UI.swc  -- myApp.mxml

              Lors d’un développement avec Flash Builder, ajoutez le fichier SWC dans l’onglet Chemin de la bibliothèque des paramètres du chemin de création Flex de la boîte de dialogue Propriétés.

              Assurez-vous de copier les fichiers SWC vers le répertoire que vous référencerez dans le compilateur amxmlc (avec le kit SDK Flex) ou Flash Builder.

              Intégration des fichiers de la structure dans une application AIR de type HTML

              Le répertoire frameworks/html de la structure de mise à jour contient les fichiers SWF suivants :

              • applicationupdater.swf : définit les fonctionnalités de base de la bibliothèque de mise à jour, sans interface utilisateur.

              • applicationupdater_ui.swf : définit les fonctionnalités de base de la bibliothèque de mise à jour, notamment une interface utilisateur qui permet à l’application d’afficher les options de mise à jour.

              Le code JavaScript des applications AIR peut utiliser les classes définies dans les fichiers SWF.

              Pour utiliser la structure de mise à jour, intégrez le fichier applicationupdater.swf ou applicationupdater_ui.swf dans le répertoire (ou un sous-répertoire) de l’application. Ensuite, dans le fichier HTML qui utilisera la structure (dans le code JavaScript), insérez une balise script chargeant le fichier :

              <script src="applicationUpdater.swf" type="application/x-shockwave-flash"/>

              Vous pouvez également charger le fichier applicationupdater_ui.swf à l’aide de la balise script :

              <script src="applicationupdater_ui.swf" type="application/x-shockwave-flash"/>

              L’API définie dans ces deux fichiers est décrite dans la suite de ce document.

              Exemple de base : utilisation de la version ApplicationUpdaterUI

              La version ApplicationUpdaterUI de la structure de mise à jour propose une interface de base que vous pouvez facilement utiliser dans l’application. Voici un exemple de base.

              D’abord, créez une application AIR qui appelle la structure de mise à jour :

              1. S’il s’agit d’une application AIR de type HTML, chargez le fichier applicationupdaterui.swf :

                <script src="ApplicationUpdater_UI.swf" type="application/x-shockwave-flash"/>

              2. Dans la logique du programme de l’application AIR, instanciez un objet ApplicationUpdaterUI.

                Dans ActionScript, utilisez le code suivant :

                var appUpdater:ApplicationUpdaterUI = new ApplicationUpdaterUI();

                Dans JavaScript, utilisez le code suivant :

                var appUpdater = new runtime.air.update.ApplicationUpdaterUI();

                Vous pouvez ajouter ce code dans une fonction d’initialisation qui s’exécute après le chargement de l’application.

              3. Créez un fichier texte nommé updateConfig.xml et ajoutez-lui les éléments suivants :

                <?xml version="1.0" encoding="utf-8"?> 
<configuration xmlns="http://ns.adobe.com/air/framework/update/configuration/1.0"> 
     <url>http://example.com/updates/update.xml</url> 
    <delay>1</delay> 
</configuration>

                Modifiez l’élément URL du fichier updateConfig.xml pour qu’il corresponde à l’emplacement final du fichier descripteur de la mise à jour sur votre serveur Web (voir la procédure suivante).

                L’élément delay définit le nombre de jours devant s’écouler avant que l’application ne vérifie la présence de nouvelles mises à jour.

              4. Ajoutez le fichier updateConfig.xml dans le répertoire de projet de l’application AIR.

              5. Faites en sorte que l’objet updater fasse référence au fichier updateConfig.xml, et appelez la méthode initialize() de l’objet.

                Dans ActionScript, utilisez le code suivant :
                appUpdater.configurationFile = new File("app:/updateConfig.xml"); 
appUpdater.initialize();
                Dans JavaScript, utilisez le code suivant :
                appUpdater.configurationFile = new air.File("app:/updateConfig.xml"); 
appUpdater.initialize();

              6. Créez une seconde version de l’application AIR dont la version diffère de la première application. (La version est spécifiée dans le fichier descripteur de l’application, dans l’élément version.)

              Ajoutez ensuite la mise à jour de l’application AIR sur le serveur Web :

              1. Placez la version mise à jour du fichier AIR sur le serveur Web.

              2. Créez un fichier texte, updateDescriptor.2.5.xml, et ajoutez-lui le contenu suivant :

                <?xml version="1.0" encoding="utf-8"?> 
     <update xmlns="http://ns.adobe.com/air/framework/update/description/2.5"> 
       <versionNumber>1.1</versionNumber> 
       <url>http://example.com/updates/sample_1.1.air</url> 
       <description>This is the latest version of the Sample application.</description> 
    </update>

                Modifiez les éléments versionNumber, URL et description du fichier updateDescriptor.xml en fonction du fichier AIR de mise à jour. Ce format de fichier descripteur de mise à jour est utilisé par les applications qui font appel à la structure de mise à jour intégrée au kit SDK d’AIR 2.5 (et ultérieur).

              3. Créez un fichier texte, updateDescriptor.1.0.xml, et ajoutez-lui le contenu suivant :

                <?xml version="1.0" encoding="utf-8"?> 
     <update xmlns="http://ns.adobe.com/air/framework/update/description/1.0"> 
       <version>1.1</version> 
       <url>http://example.com/updates/sample_1.1.air</url> 
       <description>This is the latest version of the Sample application.</description> 
    </update>

                Modifiez les éléments version, URL et description du fichier updateDescriptor.xml en fonction du fichier AIR de mise à jour. Ce format de fichier descripteur de mise à jour est utilisé par les applications qui font appel à la structure de mise à jour intégrée au kit SDK d’AIR 2 (et ultérieur).

                Remarque : la création de ce second fichier descripteur de mise à jour ne s’impose que si vous prenez en charge les mises à jour d’applications créées avant AIR 2.5.

              4. Placez les fichiers updateDescriptor.2.5.xml et updateDescriptor.1.0.xml dans le répertoire du serveur Web qui contient le fichier AIR de mise à jour.

              Il s’agit là d’un exemple de base, mais il fournit des fonctionnalités de mise à jour suffisantes pour la plupart des applications. La suite de ce document décrit l’utilisation de la structure de mise à jour en fonction de vos besoins.

              Pour accéder à un autre exemple d’utilisation de la structure de mise à jour, voir les exemples d’application suivants dans le Centre des développeurs d’Adobe AIR :

              Mise à jour vers AIR 2.5

              En raison de la modification des règles d’affectation de numéro de version aux applications dans AIR 2.5, la structure de mise à jour d’AIR 2 ne peut pas analyser les informations de version dans un fichier descripteur d’application AIR 2.5. Cette incompatibilité signifie que vous devez mettre à jour l’application de sorte à utiliser la nouvelle structure de mise à jour AVANT de mettre à jour l’application de sorte à utiliser le kit SDK d’AIR 2.5. Par conséquent, mettre à jour l’application vers AIR 2.5 ou ultérieur à partir de n’importe quelle version d’AIR antérieure à 2.5 nécessite DEUX mises à jour. La première mise à jour doit utiliser l’espace de noms d’AIR 2 et inclure la bibliothèque de la structure de mise à jour d’AIR 2.5 (vous pouvez continuer à mettre en package l’application à l’aide du kit SDK d’AIR 2.5). La seconde mise à jour peut faire appel à l’espace de noms d’AIR 2.5 et inclure les nouvelles fonctionnalités de l’application.

              Vous pouvez également restreindre la mise à jour intermédiaire à la mise à jour de l’application AIR 2.5 directement par le biais de la classe Updater d’AIR.

              L’exemple suivant illustre la procédure de mise à jour d’une application de la version 1.0 à la version 2.0. La version 1.0 utilise l’ancien espace de noms 2.0. La version 2.0 fait appel à l’espace de noms 2.5 et possède les nouvelles fonctionnalités mises en œuvre par le biais des API d’AIR 2.5.

              1. Créez une version intermédiaire de l’application, version 1.0.1, basée sur la version 1.0 de l’application.

                1. Créez l’application dans la structure de mise à jour de l’application d’AIR 2.5.

                  Remarque : utilisez le fichier applicationupdater.swc ou applicationupdater_ui.swc pour les applications AIR basées sur la technologie Flash, le fichier applicationupdater.swf ou applicationupdater_ui.swf pour les applications AIR de type HTML.

                2. Créez un fichier descripteur de mise à jour associé à la version 1.0.1 en utilisant l’ancien espace de noms et la version, comme illustré ci-après :

                  <?xml version="1.0" encoding="utf-8"?> 
    <update xmlns="http://ns.adobe.com/air/framework/update/description/2.0"> 
        <version>1.0.1</version> 
        <url>http://example.com/updates/sample_1.0.1.air</url> 
        <description>This is the intermediate version.</description> 
    </update>

              2. Créez la version 2.0 de l’application, qui utilise les API et l’espace de noms d’AIR 2.5.

              3. Créez un fichier descripteur de mise à jour pour mettre à jour l’application de la version 1.0.1 à la version 2.0.

              <?xml version="1.0" encoding="utf-8"?> 
    <update xmlns="http://ns.adobe.com/air/framework/update/description/2.5"> 
        <version>2.0</version> 
        <url>http://example.com/updates/sample_2.0.air</url> 
        <description>This is the intermediate version.</description> 
    </update>

              Définition des fichiers descripteurs de mise à jour et ajout du fichier AIR dans le serveur Web

              Lorsque vous utilisez la structure de mise à jour d’AIR, vous définissez les informations de base relatives à la mise à jour disponible dans des fichiers descripteurs de mise à jour, stockés sur le serveur Web. Un fichier descripteur de mise à jour est un simple fichier XML. La structure de mise à jour intégrée à l’application examine ce fichier pour savoir si une nouvelle version a été téléchargée.

              Le format du fichier descripteur de mise à jour a été modifié dans AIR 2.5 et utilise à présent un autre espace de noms. L’espace de noms d’origine correspond à « http://ns.adobe.com/air/framework/update/description/1.0 ». L’espace de noms d’AIR 2.5 correspond à « http://ns.adobe.com/air/framework/update/description/2.5 ».

              Les applications AIR créées avant AIR 2.5 ne lisent que la version 1.0 du descripteur de mise à jour. Les applications AIR créées avec la structure de mise à jour intégrée à AIR 2.5 ou ultérieur ne lisent que la version 2.5 du descripteur de mise à jour. En raison de cette incompatibilité des versions, il s’avère souvent nécessaire de créer deux fichiers descripteurs de mise à jour. La logique de mise à jour des versions AIR 2.5 de l’application doit télécharger un descripteur de mise à jour qui utilise le nouveau format. Les versions antérieures de l’application AIR doivent continuer à utiliser le format d’origine. Les deux fichiers doivent être modifiés pour chaque mise à jour (jusqu’à ce que vous arrêtiez la prise en charge des versions créées avant AIR 2.5).

              Le fichier descripteur de mise à jour contient les données suivantes :

              • versionNumber : nouvelle version de l’application AIR. Utilisez l’élément versionNumber dans les descripteurs de mise à jour associés à la mise à jour des applications AIR 2.5. La valeur doit correspondre à la chaîne que contient l’élément versionNumber du fichier descripteur de la nouvelle application AIR. Si le numéro de version indiqué dans le fichier descripteur de mise à jour ne correspond pas à celui du fichier AIR de mise à jour, la structure de mise à jour renvoie une exception.

              • version : nouvelle version de l’application AIR. Utilisez·l’élément·version·dans·les fichiers descripteurs·de·mise·à·jour·associés·à·la·mise·à·jour·des·applications·créées·avant·AIR¬2.5.·La valeur doit correspondre à la chaîne que contient l’élément version du fichier descripteur de la nouvelle application AIR. Si la version indiquée dans le fichier descripteur de mise à jour ne correspond pas à celle du fichier AIR de mise à jour, la structure de mise à jour renvoie une exception.

              • versionLabel : chaîne de version intelligible destinée à être présentée aux utilisateurs. L’élément versionLabel est facultatif, mais est réservé à la version 2.5 des fichiers descripteurs de mise à jour. Utilisez-le si le fichier descripteur d’application contient un élément versionLabel défini sur la même valeur.

              • url : emplacement du fichier AIR de mise à jour. Ce fichier contient la version mise à jour de l’application AIR.

              • description : détails de la nouvelle version. Ces informations peuvent s’afficher pour l’utilisateur pendant le processus de mise à jour.

              Les éléments version et url sont obligatoires. L’élément description est facultatif.

              Voici un exemple de fichier descripteur de mise à jour (version 2.5) :

              <?xml version="1.0" encoding="utf-8"?> 
     <update xmlns="http://ns.adobe.com/air/framework/update/description/2.5"> 
       <versionNumber>1.1.1</versionNumber> 
       <url>http://example.com/updates/sample_1.1.1.air</url> 
       <description>This is the latest version of the Sample application.</description> 
    </update>

              Et voici un exemple de fichier descripteur de mise à jour (version 1.0) :

              <?xml version="1.0" encoding="utf-8"?> 
     <update xmlns="http://ns.adobe.com/air/framework/update/description/1.0"> 
       <version>1.1.1</version> 
       <url>http://example.com/updates/sample_1.1.1.air</url> 
       <description>This is the latest version of the Sample application.</description> 
    </update>

              Pour définir la balise description avec plusieurs langues, utilisez plusieurs éléments text définissant un attribut lang :

              <?xml version="1.0" encoding="utf-8"?> 
     <update xmlns="http://ns.adobe.com/air/framework/update/description/2.5"> 
       <versionNumber>1.1.1</versionNumber> 
       <url>http://example.com/updates/sample_1.1.1.air</url> 
       <description> 
           <text xml:lang="en">English description</text> 
           <text xml:lang="fr">French description</text> 
           <text xml:lang="ro">Romanian description</text> 
       </description> 
    </update>

              Placez le fichier descripteur de mise à jour et le fichier AIR de mise à jour sur le serveur Web.

              Le répertoire templates inclus avec le descripteur de mise à jour comprend des exemples de fichiers descripteur de mise à jour. Ces derniers comprennent des versions de langage unique et des versions multilingues.

              Instanciation d’un objet updater

              Au terme du chargement de la structure de mise à jour d’AIR dans le code (voir Configuration de l’environnement de développement Flex et Intégration des fichiers de la structure dans une application AIR de type HTML), vous devez instancier un objet updater, comme illustré par l’exemple suivant.

              Exemple ActionScript :

              var appUpdater:ApplicationUpdater = new ApplicationUpdater();

              Exemple JavaScript :

              var appUpdater = new runtime.air.update.ApplicationUpdater();

              Le code précédent utilise la classe ApplicationUpdater (qui ne fournit pas d’interface utilisateur). Pour faire appel à la classe ApplicationUpdaterUI (qui fournit une interface utilisateur), utilisez le code suivant.

              Exemple ActionScript :

              var appUpdater:ApplicationUpdaterUI = new ApplicationUpdaterUI();

              Exemple JavaScript :

              var appUpdater = new runtime.air.update.ApplicationUpdaterUI();

              Les autres exemples de code de ce document supposent que vous avez instancié un objet updater nommé appUpdater.

              Configuration des paramètres de la mise à jour

              Les classes ApplicationUpdater et ApplicationUpdaterUI peuvent être configurées par l’intermédiaire d’un fichier de configuration fourni avec l’application ou par le code ActionScript ou JavaScript de l’application.

              Définition des paramètres de la mise à jour dans un fichier de configuration XML

              Ce fichier de configuration de la mise à jour est un fichier XML. Il peut contenir les éléments suivants :

              • updateURL : chaîne représentant l’emplacement du descripteur de la mise à jour sur le serveur distant. Tout emplacement URLRequest valide est autorisé. Vous devez définir la propriété updateURL, par l’intermédiaire du fichier de configuration ou du script (voir Définition des fichiers descripteurs de mise à jour et ajout du fichier AIR dans le serveur Web). Vous devez définir cette propriété avant d’utiliser l’objet updater (avant d’appeler la méthode initialize() de l’objet updater, décrite à la section Initialisation de la structure de mise à jour).

              • delay : nombre représentant un intervalle de jours donné (des valeurs comme 0.25 sont autorisées) correspondant à la fréquence de vérification de la présence de mises à jour. Une valeur 0 (définie par défaut) spécifie que l’objet updater ne vérifie pas automatiquement la présence de mise à jour.

              Le fichier de configuration d’ApplicationUpdaterUI peut contenir l’élément suivant en plus des éléments updateURL et delay :

              • defaultUI : liste des éléments dialog. Chaque élément dialog possède un attribut name correspondant à une boîte de dialogue de l’interface utilisateur. Chaque élément dialog possède un attribut visible qui spécifie si la boîte de dialogue est visible. La valeur par défaut est true. Les valeurs possibles de l’attribut name sont les suivantes :

                • "checkForUpdate" : correspondant aux boîtes de dialogue Rechercher une mise à jour, Aucune mise à jour et Erreur de mise à jour.

                • "downloadUpdate" : correspondant à la boîte de dialogue Télécharger la mise à jour.

                • "downloadProgress" : correspondant aux boîtes de dialogue Progression du téléchargement et Erreur de téléchargement.

                • "installUpdate" : correspondant à la boîte de dialogue Installer la mise à jour.

                • "fileUpdate" : correspondant aux boîtes de dialogue Mise à jour des fichiers, Aucune mise à jour de fichiers et Erreur de fichier.

              • "unexpectedError" : correspondant à la boîte de dialogue Erreur imprévue.

                Lorsque l’attribut est défini sur false, la boîte de dialogue correspondante ne s’affiche pas dans le cadre de la procédure de mise à jour.

              Voici un exemple de fichier de configuration pour la structure ApplicationUpdater : 

              <?xml version="1.0" encoding="utf-8"?> 
<configuration xmlns="http://ns.adobe.com/air/framework/update/configuration/1.0"> 
      <url>http://example.com/updates/update.xml</url> 
      <delay>1</delay> 
</configuration>

              Voici un exemple de fichier de configuration pour la structure ApplicationUpdaterUI, comprenant une définition de l’élément defaultUI :

              <?xml version="1.0" encoding="utf-8"?> 
<configuration xmlns="http://ns.adobe.com/air/framework/update/configuration/1.0"> 
      <url>http://example.com/updates/update.xml</url> 
      <delay>1</delay> 
      <defaultUI> 
         <dialog name="checkForUpdate" visible="false" /> 
         <dialog name="downloadUpdate" visible="false" /> 
         <dialog name="downloadProgress" visible="false" /> 
      </defaultUI> 
</configuration>

              Pointez la propriété configurationFile vers l’emplacement du fichier :

              Exemple ActionScript :

              appUpdater.configurationFile = new File("app:/cfg/updateConfig.xml");
              Exemple JavaScript :
              appUpdater.configurationFile = new air.File("app:/cfg/updateConfig.xml");

              Le répertoire templates de la structure de mise à jour comprend un exemple de fichier de configuration, config-template.xml.

              Définition des paramètres de mise à jour dans le code ActionScript ou JavaScript

              Ces paramètres de configuration peuvent également être définis dans le code de l’application, comme dans le code suivant :

              appUpdater.updateURL = " http://example.com/updates/update.xml"; 
appUpdater.delay = 1;

              Les propriétés de l’objet updater sont updateURL et delay. Ces propriétés définissent les mêmes paramètres que les éléments updateURL et delay dans le fichier de configuration : l’URL du fichier descripteur de mise à jour et l’intervalle de vérification des mises à jour. Si vous spécifiez un fichier de configuration et des paramètres dans le code, toutes les propriétés définies à l’aide du code sont prioritaires sur les paramètres correspondants dans le fichier de configuration.

              Vous devez définir la propriété updateURL, par l’intermédiaire du fichier de configuration ou du script (voir Définition des fichiers descripteurs de mise à jour et ajout du fichier AIR dans le serveur Web), avant d’utiliser l’objet updater (avant d’appeler la méthode initialize() de l’objet updater, décrite à la section Initialisation de la structure de mise à jour).

              La structure ApplicationUpdaterUI définit les propriétés supplémentaires suivantes de l’objet updater :

              • isCheckForUpdateVisible : correspondant aux boîtes de dialogue Rechercher une mise à jour, Aucune mise à jour et Erreur de mise à jour.

              • isDownloadUpdateVisible : correspondant à la boîte de dialogue Télécharger une mise à jour.

              • isDownloadProgressVisible : correspondant aux boîtes de dialogue Progression du téléchargement et Erreur de téléchargement.

              • isInstallUpdateVisible : correspondant à la boîte de dialogue Installer la mise à jour.

              • isFileUpdateVisible : correspondant aux boîtes de dialogue Mise à jour des fichiers, Aucune mise à jour de fichiers et Erreur de fichier.

              • isUnexpectedErrorVisible : correspondant à la boîte de dialogue Erreur imprévue.

              Chaque propriété correspond à une ou plusieurs boîtes de dialogue de l’interface utilisateur ApplicationUpdaterUI. Chaque propriété est une valeur booléenne, dont la valeur par défaut est true. Lorsqu’elle est définie sur false, les boîtes de dialogue correspondantes ne s’affichent pas lors de la procédure de mise à jour.

              Les propriétés de ces boîtes de dialogue remplacent les paramètres du fichier de configuration de mise à jour.

              Processus de mise à jour

              La structure de mise à jour AIR complète le processus de mise à jour selon la procédure suivante :

              1. L’initialisation du programme de mise à jour contrôle si une vérification de mise à jour a été effectuée au cours de l’intervalle défini (voir Configuration des paramètres de la mise à jour). Si une vérification de mise à jour doit être effectuée, le processus se poursuit.

              2. Le programme de mise à jour télécharge et interprète le fichier descripteur de mise à jour.

              3. Le programme de mise à jour télécharge le fichier AIR de mise à jour.

              4. Le programme de mise à jour installe la version mise à jour de l’application.

              L’objet updater distribue des événements à la fin de chacune de ces étapes. Dans la version ApplicationUpdater, vous pouvez annuler les événements qui indiquent le succès d’une étape du processus. Si vous annulez l’un de ces événements, l’étape suivante du processus est annulée. Dans la version ApplicationUpdaterUI, le programme de mise à jour affiche une boîte de dialogue qui permet à l’utilisateur d’annuler ou de continuer à chaque étape du processus.

              Si vous annulez l’événement, vous pouvez appeler les méthodes de l’objet updater pour reprendre le processus.

              Au fur et à mesure que la version ApplicationUpdater du programme de mise à jour poursuit le processus, l’état en cours est enregistré dans une propriété currentState. Cette propriété est définie sur une chaîne qui peut prendre les valeurs suivantes :

              • "UNINITIALIZED" : le programme de mise à jour n’a pas été initialisé.

              • "INITIALIZING" : le programme de mise à jour est en cours d’initialisation.

              • "READY" : le programme de mise à jour a été initialisé.

              • "BEFORE_CHECKING" : le programme de mise à jour n’a pas encore vérifié la présence du fichier descripteur de mise à jour.

              • "CHECKING" : le programme de mise à jour recherche un fichier descripteur de mise à jour.

              • "AVAILABLE" : le fichier descripteur de mise à jour est disponible.

              • "DOWNLOADING" : le programme de mise à jour télécharge le fichier AIR.

              • "DOWNLOADED" : le programme de mise à jour a téléchargé le fichier AIR.

              • "INSTALLING" : le programme de mise à jour installe le fichier AIR.

              • "PENDING_INSTALLING" : le programme de mise à jour a été initialisé et des mises à jour sont en attente.

              Certaines méthodes de l’objet updater ne s’exécutent que si le programme de mise à jour est dans un certain état.

              Initialisation de la structure de mise à jour

              Après la définition des propriétés de configuration (voir Exemple de base : utilisation de la version ApplicationUpdaterUI), appelez la méthode initialize() pour initialiser la mise à jour :

              appUpdater.initialize();

              Cette méthode effectue les opérations suivantes :

              • Elle initialise la structure de mise à jour, en installant silencieusement et de façon synchrone les mises à jour en attente. Il est obligatoire d’appeler cette méthode au démarrage de l’application car elle peut redémarrer l’application lorsqu’elle est appelée.

              • Elle vérifie si une mise à jour a été reportée et, le cas échéant, procède à son installation.

              • Si une erreur se produit pendant le processus de mise à jour, elle efface le fichier de mise à jour et les informations de version dans l’emplacement de stockage de l’application.

              • Si le délai est arrivé à expiration, elle démarre le processus de mise à jour. Sinon, elle réinitialise le minuteur.

              L’appel à cette méthode peut entraîner la distribution des événements suivants par l’objet updater :

              • UpdateEvent.INITIALIZED : distribué lorsque l’initialisation est terminée.

              • ErrorEvent.ERROR : distribué lorsqu’une erreur se produit pendant l’initialisation.

              Lors de la distribution de l’événement UpdateEvent.INITIALIZED, le processus de mise à jour est terminé.

              Lorsque vous appelez la méthode initialize(), le programme de mise à jour démarre le processus et effectue toutes les étapes, en fonction du paramètre de délai du minuteur. Toutefois, vous pouvez également démarrer le processus de mise à jour à tout moment en appelant la méthode checkNow() de l’objet updater :

              appUpdater.checkNow();

              Cette méthode n’a aucune incidence si le processus de mise à jour est déjà en cours d’exécution. Sinon, elle démarre le processus de mise à jour.

              L’objet updater peut distribuer l’événement suivant après un appel à la méthode checkNow() :

              • L’événement UpdateEvent.CHECK_FOR_UPDATE juste avant la tentative de téléchargement du fichier descripteur de mise à jour.

              Si vous annulez l’événement checkForUpdate, vous pouvez appeler la méthode checkForUpdate() de l’objet updater. (Voir la section suivante.) Si vous n’annulez pas l’événement, le processus de mise jour recherche le fichier descripteur de mise à jour.

              Gestion du processus de mise à jour dans la version ApplicationUpdaterUI

              Dans la version ApplicationUpdaterUI, l’utilisateur peut annuler le processus via les boutons Annuler des boîtes de dialogue de l’interface utilisateur. De même, vous pouvez annuler par programmation le processus de mise à jour en appelant la méthode cancelUpdate() de l’objet ApplicationUpdaterUI.

              Vous pouvez définir les propriétés de l’objet ApplicationUpdaterUI ou définir les éléments du fichier de configuration de mise à jour pour spécifier les confirmations de boîtes de dialogue devant être affichées par le programme de mise à jour. Pour plus d’informations, voir Configuration des paramètres de la mise à jour.

              Gestion du processus de mise à jour dans la version ApplicationUpdater

              Vous pouvez appeler la méthode preventDefault() des objets d’événements distribués par l’objet ApplicationUpdater pour annuler des étapes du processus de mise à jour (voir Processus de mise à jour). L’annulation du comportement par défaut permet à votre application d’afficher un message à l’utilisateur pour lui demander s’il souhaite continuer.

              Les sections suivantes montrent comment poursuivre le processus de mise à jour lorsqu’une étape du processus a été annulée.

              Téléchargement et interprétation du fichier descripteur de mise à jour

              L’objet ApplicationUpdater distribue l’événement checkForUpdate avant le début du processus de mise à jour, juste avant que le programme de mise à jour ne tente de télécharger le fichier descripteur de mise à jour. Si vous annulez le comportement par défaut de l’événement checkForUpdate, le programme de mise à jour ne télécharge pas le fichier descripteur de mise à jour. Pour reprendre le processus de mise à jour, vous pouvez appeler la méthode checkForUpdate() :

              appUpdater.checkForUpdate();

              L’appel à la méthode checkForUpdate() oblige le programme de mise à jour à effectuer un téléchargement asynchrone et à interpréter le fichier descripteur de mise à jour. À la suite d’un appel à la méthode checkForUpdate(), l’objet updater peut distribuer les événements suivants :

              • StatusUpdateEvent.UPDATE_STATUS : le programme de mise à jour à bien téléchargé et interprété le fichier descripteur de mise à jour. Les propriétés de cet événement sont les suivantes :

                • available : valeur booléenne. Définie sur true si une version différente de l’application en cours est disponible, sur false dans le cas contraire (la version est identique).

                • version : chaîne. La version indiquée dans le fichier descripteur d’application du fichier de mise à jour.

                • details : tableau. S’il n’y a pas de versions localisées de la description, ce tableau renvoie une chaîne vide ("") en tant que premier élément et la description en tant que second élément.

                  S’il existe plusieurs versions de la description (dans le fichier descripteur de mise à jour), le tableau contient plusieurs sous-tableaux. Chaque tableau comprend deux éléments : le premier étant le code de langue (par exemple "en"), et le second la description correspondante (une chaîne) dans cette langue. Voir Définition des fichiers descripteurs de mise à jour et ajout du fichier AIR dans le serveur Web.

              • StatusUpdateErrorEvent.UPDATE_ERROR : une erreur s’est produite et le programme de mise à jour n’a pas pu télécharger ou interpréter le fichier descripteur de mise à jour.

              Téléchargement du fichier AIR de mise à jour

              L’objet ApplicationUpdater distribue l’événement updateStatus dès que le programme de mise à jour à bien téléchargé et interprété le fichier descripteur de mise à jour. Le comportement par défaut consiste à démarrer le téléchargement du fichier de mise à jour lorsque ce dernier est disponible. Si vous annulez le comportement par défaut, vous pouvez reprendre le processus en appelant la méthode downloadUpdate() :

              appUpdater.downloadUpdate();

              L’appel de cette méthode oblige le programme de mise à jour à effectuer un téléchargement asynchrone de la mise à jour du fichier AIR.

              La méthode downloadUpdate() peut distribuer les événements suivants :

              • UpdateEvent.DOWNLOAD_START : la connexion au serveur a été établie. Lorsque la bibliothèque ApplicationUpdaterUI est utilisée, cet événement affiche une boîte de dialogue dans laquelle une barre de progression permet de suivre l’avancée du téléchargement.

              • ProgressEvent.PROGRESS : distribué régulièrement au fur et à mesure de la progression du téléchargement du fichier.

              • DownloadErrorEvent.DOWNLOAD_ERROR : distribué lorsqu’une erreur se produit pendant la connexion ou le téléchargement du fichier de mise à jour. Cet événement est également distribué pour les états HTTP non valides (par exemple « 404 - Fichier introuvable »). Cet événement a une propriété errorID, un nombre entier qui définit d’autres informations d’erreur. Une autre propriété subErrorID peut contenir d’autres informations d’erreur.

              • UpdateEvent.DOWNLOAD_COMPLETE : le programme de mise à jour à bien téléchargé et interprété le fichier descripteur de mise à jour. Si vous n’annulez pas cet événement, la version ApplicationUpdater procède à l’installation de la mise à jour. Dans la version ApplicationUpdaterUI, une boîte de dialogue est présentée à l’utilisateur pour lui proposer de continuer.

              Mise à jour de l’application

              L’objet ApplicationUpdater déclenche l’événement downloadComplete lorsque le téléchargement du fichier de mise à jour est terminé. Si vous annulez le comportement par défaut, vous pouvez reprendre le processus en appelant la méthode installUpdate() :

              appUpdater.installUpdate(file);

              Un appel à cette méthode oblige le programme de mise à jour à installer la mise à jour du fichier AIR. La méthode comprend un paramètre, file, correspondant à un objet File qui fait référence au fichier AIR à utiliser en tant que mise à jour.

              L’objet ApplicationUpdater peut distribuer l’événement beforeInstall à la suite d’un appel à la méthode installUpdate() :

              • UpdateEvent.BEFORE_INSTALL : distribué juste avant l’installation de la mise à jour. Il est parfois utile d’empêcher l’installation de la mise à jour à ce stade de sorte que l’utilisateur puisse terminer son travail en cours avant de lancer l’installation. L’appel à la méthode preventDefault() de l’objet Event reporte l’installation jusqu’au prochain démarrage et empêche le lancement de tout processus de mise à jour supplémentaire. (Cela comprend les mises à jour résultant d’un appel à la méthode checkNow() ou liées à une vérification périodique.)

              Installation à partir d’un fichier AIR arbitraire

              Vous pouvez appeler la méthode installFromAIRFile() pour installer la mise à jour à partir d’un fichier AIR situé sur l’ordinateur de l’utilisateur :

              appUpdater.installFromAIRFile();

              Cette méthode oblige le programme de mise à jour à installer la mise à jour de l’application à partir du fichier AIR.

              La méthode installFromAIRFile() peut distribuer les événements suivants :

              • StatusFileUpdateEvent.FILE_UPDATE_STATUS : distribué lorsque ApplicationUpdater a bien validé le fichier envoyé par la méthode installFromAIRFile(). Les propriétés de cet événement sont les suivantes :

                • available : définie sur true si une version différente de l’application actuelle est disponible ; false, dans le cas contraire (les versions sont identiques).

                • version : chaîne représentant la nouvelle version disponible.

                • path : représente le chemin natif du fichier de mise à jour.

                Vous pouvez annuler cet événement si la propriété available de l’objet StatusFileUpdateEvent est définie sur true. L’annulation de l’événement annule également le processus de mise à jour. Pour poursuivre le processus de mise à jour, appelez la méthode installUpdate().

              • StatusFileUpdateErrorEvent.FILE_UPDATE_ERROR : une erreur s’est produite et le programme de mise à jour n’a pas pu installer l’application AIR.

              Annulation du processus de mise à jour

              Pour annuler le processus de mise à jour, vous pouvez appeler la méthode cancelUpdate() :

              appUpdater.cancelUpdate();

              Cette méthode annule tous les téléchargements en attente, en supprimant tous les fichiers partiellement téléchargés, et réinitialise le minuteur de vérification périodique.

              Cette méthode n’a aucune incidence si le programme de mise à jour est initialisé.

              Localisation de l’interface ApplicationUpdaterUI

              La classe ApplicationUpdaterUI fournit une interface utilisateur par défaut pour le processus de mise à jour. Celle-ci comprend des boîtes de dialogue qui permettent à l’utilisateur de démarrer le processus, de l’annuler et d’effectuer d’autres actions associées.

              L’élément description du fichier descripteur de mise à jour vous permet de définir la description de l’application en plusieurs langues. Utilisez plusieurs éléments text définissant des attributs lang, comme dans l’exemple suivant :

              <?xml version="1.0" encoding="utf-8"?> 
     <update xmlns="http://ns.adobe.com/air/framework/update/description/1.0"> 
       <version>1.1a1</version> 
       <url>http://example.com/updates/sample_1.1a1.air</url> 
       <description> 
           <text xml:lang="en">English description</text> 
           <text xml:lang="fr">French description</text> 
           <text xml:lang="ro">Romanian description</text> 
       </description> 
    </update>

              La structure de mise à jour utilise la description correspondant le mieux au chaînage de localisation de l’utilisateur final. Pour plus d’informations, voir Définition du fichier descripteur de mise à jour et ajout du fichier AIR dans votre serveur Web.

              Les développeurs Flex peuvent ajouter directement une nouvelle langue dans le regroupement "ApplicationUpdaterDialogs".

              Les développeurs JavaScript peuvent appeler la méthode addResources() de l’objet updater. Cette méthode ajoute dynamiquement un nouveau regroupement de ressources pour une langue. Le regroupement de ressources définit les chaînes localisées d’une langue. Ces chaînes sont utilisées dans les champs de texte des différentes boîtes de dialogue.

              Les développeurs JavaScript peuvent utiliser la propriété localeChain de la classe ApplicationUpdaterUI pour définir la chaîne de paramètres régionaux utilisée par l’interface utilisateur. En général, seuls les développeurs JavaScript (HTML) utilisent cette propriété. Les développeurs Flex peuvent utiliser ResourceManager pour gérer la chaîne de paramètres régionaux.

              Par exemple, le code JavaScript suivant définit des regroupements de ressources pour le roumain et le hongrois :

              appUpdater.addResources("ro_RO", 
                    {titleCheck: "Titlu", msgCheck: "Mesaj", btnCheck: "Buton"}); 
appUpdater.addResources("hu", {titleCheck: "Cím", msgCheck: "Üzenet"}); 
var languages = ["ro", "hu"]; 
languages = languages.concat(air.Capabilities.languages); 
var sortedLanguages = air.Localizer.sortLanguagesByPreference(languages, 
                         air.Capabilities.language, 
                         "en-US"); 
sortedLanguages.push("en-US"); 
appUpdater.localeChain = sortedLanguages;

              Pour plus d’informations, voir la description de la méthode addResources() de la classe ApplicationUpdaterUI dans le guide de référence du langage.