http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/cli/index.md ---------------------------------------------------------------------- diff --git a/www/docs/fr/7.x/guide/cli/index.md b/www/docs/fr/7.x/guide/cli/index.md new file mode 100644 index 0000000..256a720 --- /dev/null +++ b/www/docs/fr/7.x/guide/cli/index.md @@ -0,0 +1,419 @@ +--- +license: > + Licensed to the Apache Software Foundation (ASF) under one + or more contributor license agreements. See the NOTICE file + distributed with this work for additional information + regarding copyright ownership. The ASF licenses this file + to you under the Apache License, Version 2.0 (the + "License"); you may not use this file except in compliance + with the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, + software distributed under the License is distributed on an + "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, either express or implied. See the License for the + specific language governing permissions and limitations + under the License. + +title: "L'Interface en ligne de commande" +toc_title: Create your first app +--- + +# L'Interface en ligne de commande + +Ce guide a pour but de vous montrer comment créer des applications et les déployer sur différentes plates-formes mobiles natives à l'aide de l'Interface en Ligne de Commande (CLI) `cordova`. Cet outil vous permet de créer de nouveaux projets, les construire sur différentes plates-formes et exécuter sur des appareils réels ou au sein d'émulateurs. La CLI est le principal outil à utiliser pour le multi-plateforme de workflow décrit dans la vue d'ensemble. Dans le cas contraire, vous pouvez également utiliser la CLI pour initialiser le code du projet, puis basculez vers SDK et des outils de coquille pour la poursuite du développement des différentes plates-formes. + +## Prérequis + +Avant d'exécuter tout outil en ligne de commande, vous devez installer le SDK correspondant à chaque plate-forme ciblée. (Voir les Guides des Plates-formes pour plus de détails.) + +Afin d'ajouter le support ou de recompiler un projet pour n'importe quelle plate-forme, vous devez exécuter l'interface en ligne de commande depuis la même machine prenant en charge le SDK de la plate-forme concernée. La CLI supporte les combinaisons suivantes : + +* iOS (Mac) +* Amazon Fire OS (Mac, Linux, Windows) +* Android (Mac, Linux, Windows) +* BlackBerry 10 (Mac, Linux, Windows) +* Windows Phone 8 (Windows) +* Windows (Windows) +* Firefox OS (Mac, Linux, Windows) + +Sous Mac, la ligne de commande est accessible via l'application *Terminal*. Sur PC, celle-ci est disponible via l'*invite de commande* sous *accessoires*. + +**NOTE**: pour les plates-formes Windows uniquement, vous pouvez toujours faire votre développement sur matériel Mac en exécutant Windows dans un environnement de machine virtuelle ou en mode dual-boot. Pour les options disponibles, consultez le Guide de plate-forme Windows Phone 8 ou Windows Platform. + +Plus il est probable que vous exécutez le CLI de machines différentes, plus il est logique de maintenir un référentiel de code source éloignée, dont les actifs vous tirez vers le bas pour les répertoires de travail local. + +## Installation de la CLI de Cordova + +L'outil de ligne de commande de Cordova est distribué comme un paquet de npm dans un format prêt à l'emploi. Il n'est pas nécessaire de compiler depuis les sources. + +Pour installer le `cordova` de ligne de commande outil, procédez comme suit : + +1. Télécharger et installer [Node.js][1]. Après installation, vous devriez être capable d'appeler `node` et `npm` sur votre ligne de commande. Si vous le souhaitez, vous pouvez éventuellement utiliser un outil tel que `nvm` ou `nave` pour gérer votre installation de Node.js. + +2. Téléchargez et installez un [client git][2], si vous n'avez pas déjà un. Après installation, vous devriez être en mesure d'invoquer `git` sur votre ligne de commande. Même si vous n'utilisez pas `git` manuellement, la CLI l'utilise dans les coulisses pour télécharger certains actifs lorsque vous créez un nouveau projet. + +3. Installer le `cordova` à l'aide du module `npm` utilitaire de Node.js. Le `cordova` module sera automatiquement téléchargée par le `npm` utilitaire. + + [1]: http://nodejs.org/ + [2]: http://git-scm.com/ + +* sur OS X et Linux : + + $ sudo npm install -g cordova + + + Sur OS X et Linux, faisant précéder la `npm` commande avec `sudo` peut être nécessaire d'installer cette évolution utilitaire dans autrement limité répertoires tels que `/usr/local/share` . Si vous utilisez l'outil optionnel nvm/nef ou avez accès en écriture sur le répertoire d'installation, vous pourrez omettre la `sudo` préfixe. Il y a [plus de conseils][3] sur l'utilisation `npm` sans `sudo` , si vous désirez le faire. + +* sur Windows : + + C:\>npm install -g cordova + + + Le `-g` option ci-dessus indique `npm` pour installer `cordova` dans le monde. Dans le cas contraire il sera installé dans le `node_modules` sous-répertoire du répertoire de travail courant. + + Vous devrez peut-être ajouter le `npm` répertoire à votre `PATH` pour BENEFICIER installés dans le monde `npm` modules. Sous Windows, `npm` peut habituellement être trouvé à `C:\Users\username\AppData\Roaming\npm` . Sur OS X et Linux, il peut généralement être trouvé à `/usr/local/share/npm`. + + Le journal d'installation peut générer des erreurs pour n'importe quelle plateforme désinstallé SDK. + + Après installation, vous devriez être en mesure d'exécuter `cordova` sur la ligne de commande avec aucun argument et il doit imprimer le texte d'aide. + + [3]: http://justjs.com/posts/npm-link-developing-your-own-npm-modules-without-tears + +## Créer l'application + +Allez dans le répertoire où vous conservez votre code source et exécutez une commande comme suit : + + $ cordova create hello com.example.hello HelloWorld + + +Il peut prendre un certain temps pour la commande pour terminer, alors soyez patient. L'exécution de la commande avec le `-d` option affiche des informations sur ses progrès. + +Le premier argument *Bonjour* spécifie un répertoire à générer pour votre projet. Ce répertoire ne devrait pas déjà exister, Cordova il créera pour vous. Sa `www` sous-répertoire maisons page d'accueil de votre application, ainsi que diverses ressources sous `css` , `js` , et `img` , qui suivent les conventions de dénomination de fichier du développement des web commun. Ces actifs seront stockées sur le système de fichiers local de l'appareil, n'a ne pas servi à distance. Le `config.xml` fichier contient des métadonnées importantes nécessaires pour générer et distribuer l'application. + +Le deuxième argument `com.example.hello` met à votre projet avec un identificateur de domaine inverse-style. Cet argument est facultatif, mais seulement si vous omettez également le troisième argument, puisque les arguments sont positionnels. Vous pouvez modifier cette valeur par la suite dans le `config.xml` du fichier, mais sachez qu'il peut y avoir de code généré en dehors de `config.xml` à l'aide de cette valeur, comme les noms de package Java. La valeur par défaut est `io.cordova.hellocordova` , mais il est recommandé que vous sélectionnez une valeur appropriée. + +Le troisième argument `HelloWorld` fournit le titre d'affichage de l'application. Cet argument est facultatif. Vous pouvez modifier cette valeur par la suite dans le `config.xml` du fichier, mais sachez qu'il peut y avoir de code généré en dehors de `config.xml` à l'aide de cette valeur, tels que les noms de classes Java. La valeur par défaut est `HelloCordova` , mais il est recommandé que vous sélectionnez une valeur appropriée. + +## Ajouter des plates-formes + +Toutes les commandes suivantes doivent être exécutées dans le répertoire du projet ou les sous-répertoires dans sa portée : + + $ cd hello + + +Avant que vous pouvez générer le projet, vous devez spécifier un jeu de plates-formes cibles. Votre capacité d'exécuter ces commandes dépend de savoir si votre ordinateur prend en charge chaque SDK, et si vous avez déjà installé chaque SDK. Courir à chacun d'entre eux d'un Mac : + + $ cordova platform add ios + $ cordova platform add amazon-fireos + $ cordova platform add android + $ cordova platform add blackberry10 + $ cordova platform add firefoxos + + +Courir à chacun d'entre eux depuis une machine Windows, où *wp* se réfère aux différentes versions du système d'exploitation Windows Phone : + + plate-forme cordova $ ajouter wp8 $ cordova plate-forme ajouter windows plate-forme cordova $ ajouter amazon-fireos plateforme de cordova $ ajouter $ android plate-forme cordova ajoutez blackberry10 $ cordova plate-forme ajouter firefoxos + + +Exécutez-le pour vérifier votre noyau de plateformes : + + $ cordova platforms ls + + +(Note du `platform` et `platforms` commandes sont synonymes.) + +Exécutez une des commandes suivantes synonymes d'enlever une plate-forme : + + $ cordova platform remove blackberry10 + $ cordova platform rm amazon-fireos + $ cordova platform rm android + + +Exécution de commandes pour ajouter ou supprimer des affects de plates-formes le contenu du répertoire de *plates-formes* du projet, où chaque plate-forme spécifiée apparaît comme un sous-répertoire. Le répertoire de source *www* est reproduit dans le sous-répertoire de la plate-forme, qui apparaît par exemple dans `platforms/ios/www` ou `platforms/android/assets/www` . Parce que la CLI constamment des copies des fichiers du dossier source *www* , vous devez uniquement modifier ces fichiers et pas ceux situés dans les sous-répertoires de *plates-formes* . Si vous utilisez un logiciel de contrôle de version, vous devez ajouter ce dossier *www* source, ainsi que le dossier *se confond* , à votre système de contrôle de version. (On trouvera dans la section personnaliser chaque plate-forme ci-dessous plus d'informations sur le dossier *fusionne* .) + +**Avertissement**: lorsque vous utilisez l'interface CLI pour générer votre application, vous devriez modifier *n'est pas* tous les fichiers dans le `/platforms/` répertoire sauf si vous savez ce que vous faites, ou si la documentation spécifie autrement. Les fichiers dans ce répertoire sont systématiquement remplacés lors de la préparation des demandes de construction, ou lorsque les plugins sont réinstallés. + +Si vous le souhaitez à ce stade, vous pouvez utiliser un SDK comme Eclipse ou Xcode pour ouvrir le projet que vous avez créé. Vous devez ouvrir l'ensemble dérivé de l'actif de la `/platforms/` Répertoire de développer avec un SDK. C'est parce que les fichiers de métadonnées spécifiques de SDK sont stockés dans le cas échéant `/platform/` sous-répertoire. (Voir les [Guides de la plate-forme](../platforms/index.html) pour plus d'informations sur la façon de développer des applications au sein de chaque IDE.) Utilisez cette approche si vous souhaitez simplement initialiser un projet à l'aide de la CLI, puis passer à un SDK pour le travail indigène. + +Lire sur si vous souhaitez utiliser l'approche de flux de travail multi-plateforme (CLI) pour le cycle de développement complet. + +## Construire l'application + +Par défaut, le `cordova create` script génère une squelettique application web dont la page d'accueil est du projet `www/index.html` fichier. Modifier cette application, mais vous voulez, mais toute initialisation doit être spécifiée dans le cadre de la `[deviceready](../../cordova/events/events.deviceready.html)` gestionnaire d'événements, référencé par défaut de`www/js/index.js`. + +Exécutez la commande suivante pour générer itérativement le projet : + + $ cordova build + + +Cela génère un code spécifique à la plateforme au sein du projet `platforms` sous-répertoire. Vous pouvez éventuellement restreindre la portée de chaque génération de plates-formes spécifiques : + + $ cordova build ios + + +Le `cordova build` commande est un raccourci pour la suivante, qui, dans cet exemple, est également visé à une plate-forme unique : + + $ cordova prepare ios + $ cordova compile ios + + +Dans ce cas, une fois que vous exécutez `prepare` , vous pouvez utiliser Apple Xcode SDK comme alternative pour modifier et compiler le code spécifique à la plateforme qui génère de Cordova dans `platforms/ios` . Vous pouvez utiliser la même approche avec les kits de développement logiciel des autres plates-formes. + +## Tester l'application sur un émulateur ou un périphérique + +Kits de développement logiciel pour les plates-formes mobiles sont souvent livrés avec les émulateurs qui exécutent un élément image, afin que vous pouvez lancer l'application depuis l'écran d'accueil et voir comment il interagit avec de nombreuses fonctionnalités de la plate-forme. Exécuter une commande telle que la suivante pour reconstruire l'app et il découvre au sein de l'émulateur une spécifique de la plate-forme : + + $ cordova emulate android + + +Certaines plates-formes mobiles émulent un périphérique par défaut, tels que l'iPhone pour les projets de l'iOS. Pour d'autres plateformes, vous devrez tout d'abord associer un périphérique avec un émulateur. + +**NOTE**: support d'émulateur n'est actuellement pas disponible pour Amazon Fire OS. + +(Voir les [Guides de la plate-forme](../platforms/index.html) pour plus de détails.) Par exemple, vous pouvez d'abord exécuter la `android` commande pour lancer le SDK Android, puis exécutez une image de périphérique particulier, dont il lance selon son comportement par défaut : + +![][4] + + [4]: {{ site.baseurl }}/static/img/guide/cli/android_emulate_init.png + +Suivi auprès du `cordova emulate` commande actualise l'image de l'émulateur pour afficher la dernière application, qui est maintenant disponible pour le lancement de l'écran d'accueil : + +![][5] + + [5]: {{ site.baseurl }}/static/img/guide/cli/android_emulate_install.png + +Alternativement, vous pouvez brancher le combiné dans votre ordinateur et tester l'application directement : + + $ cordova run android + + +Avant d'exécuter cette commande, vous devez mettre en place le dispositif de test, suivant des procédures qui varient pour chaque plate-forme. Dans les appareils Android et OS feu Amazon, vous devrez activer une option de **Débogage USB** sur l'appareil et peut-être ajouter un pilote USB selon votre environnement de développement. Consultez les [Guides de la plate-forme](../platforms/index.html) pour plus de détails sur les exigences de chaque plateforme. + +## Ajouter des fonctionnalités du Plugin + +Lorsque vous générez et découvre un nouveau projet, l'application par défaut qui s'affiche ne fait pas grand chose. Vous pouvez modifier l'application de plusieurs façons de tirer parti des technologies web standard, mais l'application de communiquer étroitement avec diverses fonctions au niveau du périphérique, vous devez ajouter des plugins qui permettent d'accéder au noyau Cordova APIs. + +Un *plugin* est un peu de code complémentaire qui fournit une interface pour les composants natifs. Vous pouvez concevoir votre propre interface plugin, par exemple, lorsque vous concevez une application hybride qui mêle une Cordova WebView composants natifs. (Voir intégration WebViews et [Plugin Development Guide][6] pour plus de détails). Habituellement, vous devez ajouter un plugin pour permettre à l'une des caractéristiques de niveau périphérique base de Cordova, détaillées dans la référence de l'API. + + [6]: guide_hybrid_plugins_index.md.html#Plugin%20Development%20Guide + +Depuis la version 3.0, lorsque vous créez un projet de Cordova il n'a pas les plugins présents. C'est le nouveau comportement par défaut. Les plugins que vous désirez, même les plugins de base, doivent être ajoutés explicitement. + +On trouvera une liste de ces plugins, y compris les plugins tiers supplémentaires fournies par la Communauté, dans le registre à [plugins.cordova.io][7]. Vous pouvez utiliser l'interface CLI à la recherche de plugins de ce registre. Par exemple, la recherche de `bar` et `code` produit un résultat unique qui correspond à ces deux termes comme des sous-chaînes insensible à la casse : + + [7]: http://plugins.cordova.io/ + + $ cordova plugin search bar code + + com.phonegap.plugins.barcodescanner - Scans Barcodes + + +Vous cherchez seulement le `bar` à terme les rendements et résultats supplémentaires : + + cordova-plugin-statusbar - Cordova StatusBar Plugin + + +Le `cordova plugin add` commande nécessite vous permet de spécifier le référentiel pour le code du plugin. Voici des exemples d'utilisation de l'interface CLI pour ajouter des fonctionnalités à l'application : + +* Informations de base périphérique (Device API) : + + $ cordova plugin add cordova-plugin-device + + +* Connexion réseau et événements de la batterie : + + $ cordova plugin add cordova-plugin-network-information + $ cordova plugin add cordova-plugin-battery-status + + +* Accéléromètre, boussole et géolocalisation : + + $ cordova plugin add cordova-plugin-device-motion + $ cordova plugin add cordova-plugin-device-orientation + $ cordova plugin add cordova-plugin-geolocation + + +* Appareil photo, lecture et Capture : + + $ cordova plugin add cordova-plugin-camera + $ cordova plugin add cordova-plugin-media-capture + $ cordova plugin add cordova-plugin-media + + +* Accéder aux fichiers sur un périphérique réseau (fichier API) : + + $ cordova plugin add cordova-plugin-file + $ cordova plugin add cordova-plugin-file-transfer + + +* Notification via la boîte de dialogue ou de vibration : + + $ cordova plugin add cordova-plugin-dialogs + $ cordova plugin add cordova-plugin-vibration + + +* Contacts : + + $ cordova plugin add cordova-plugin-contacts + + +* Mondialisation : + + $ cordova plugin add cordova-plugin-globalization + + +* SplashScreen : + + $ cordova plugin add cordova-plugin-splashscreen + + +* Fenêtres ouvertes du navigateur nouvelle (InAppBrowser) : + + $ cordova plugin add cordova-plugin-inappbrowser + + +* Console de débogage : + + $ cordova plugin add cordova-plugin-console + + +**NOTE**: le CLI ajoute le code du plugin comme il convient pour chaque plate-forme. Si vous souhaitez développer avec les outils de bas niveau coque ou plate-forme SDK tel que discuté dans l'aperçu, vous devez exécuter l'utilitaire Plugman pour ajouter des plugins séparément pour chaque plate-forme. (Pour plus d'informations, voir Plugman à l'aide à gérer les Plugins). + +Utilisation `plugin ls` (ou `plugin list` , ou `plugin` en soi) à Découvre actuellement les plugins installés. Chacun affiche par son identificateur : + + $ cordova plugin ls # or 'plugin list' + [ 'cordova-plugin-console' ] + + +Pour supprimer un plugin, faire référence à elle par le même identificateur qui apparaît dans la liste. Par exemple, voici comment vous enlèverait le soutien pour une console de débogage d'une version : + + $ cordova plugin rm cordova-plugin-console + $ cordova plugin remove cordova-plugin-console # same + + +Vous pouvez lot-supprimer ou ajouter des plugins en spécifiant plusieurs arguments pour chaque commande : + + $ cordova plugin add cordova-plugin-console cordova-plugin-device + + +## Options du Plugin avancé + +Lors de l'ajout d'un plugin, plusieurs options vous permettent de spécifier où aller chercher le plugin. Les exemples ci-dessus utilisent un célèbre `registry.cordova.io` Registre, ainsi que le plugin est spécifiée par la `id` : + + $ cordova plugin add cordova-plugin-console + + +Le `id` peut également inclure le numéro de version du plugin, reproduite après un `@` caractère. La `latest` version est un alias pour la version la plus récente. Par exemple : + + $ cordova plugin add cordova-plugin-console@latest + $ cordova plugin add cordova-plugin-console@0.2.1 + + +Si le plugin n'est pas inscrite au `registry.cordova.io` mais se trouve dans un autre dépôt git, vous pouvez spécifier une URL de substitution : + + $ cordova plugin add https://github.com/apache/cordova-plugin-console.git + + +L'exemple de git ci-dessus récupère le plugin depuis la fin de la branche master, mais un autre git-Réf tel une balise ou une branche peut être ajoutée après un `#` caractère : + +Installer à partir d'une balise : + + $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#r0.2.0 + + +ou une succursale : + + $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#CB-8438cordova-plugin-console + + +ou git-Réf pourrait également être une validation particulière : + + $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#f055daec45575bf08538f885e09c85a0eba363ff + + +Si le plugin (et son fichier `plugin.xml` ) sont dans un sous-répertoire dans le repo git, vous pouvez le spécifier avec un caractère `:` . Notez que le caractère `#` est toujours nécessaire : + + $ cordova plugin add https://github.com/someone/aplugin.git#:/my/sub/dir + + +Vous pouvez également combiner le git-Réf tant le sous-répertoire : + + $ cordova plugin add https://github.com/someone/aplugin.git#r0.0.1:/my/sub/dir + + +Vous pouvez également spécifier un chemin d'accès local vers le répertoire de plugin qui contient le fichier `plugin.xml` : + + $ cordova plugin add ../my_plugin_dir + + +## à l'aide de *fusionne* pour personnaliser chaque plate-forme + +Alors que Cordoue vous permet de déployer facilement une application pour de nombreuses plateformes différentes, parfois vous avez besoin d'ajouter des personnalisations. Dans ce cas, vous ne voulez pas modifier les fichiers source dans divers répertoires `www` dans le répertoire de niveau supérieur de `platforms` , parce qu'ils sont régulièrement remplacés par source multi-plateforme du répertoire niveau supérieur `www` . + +Au lieu de cela, le répertoire de niveau supérieur `merges` offre un endroit pour spécifier des actifs de déployer sur des plates-formes spécifiques. Chaque sous-répertoire `merges`, correspondant à une plate-forme donnée, reflète la structure du répertoire source `www`, ce qui vous permet de surcharger ou ajouter des fichiers au besoin. Par exemple, voici comment vous pourriez utilisations `merges` pour augmenter la taille de police par défaut pour les appareils Android et Amazon Fire OS : + +* Modifier la `www/index.html` fichier, en ajoutant un lien vers un fichier CSS supplémentaire, `overrides.css` dans ce cas : + + <link rel="stylesheet" type="text/css" href="css/overrides.css" /> + + +* Créer éventuellement un vide `www/css/overrides.css` fichier, qui s'applique pour toutes les versions non-Android, empêchant une erreur de fichier manquant. + +* Créer un `css` sous-répertoire dans `merges/android` , puis ajoutez un correspondant `overrides.css` fichier. Spécifier CSS qui remplace la taille de police de 12 points par défaut spécifiée dans `www/css/index.css` , par exemple : + + body { font-size:14px; } + + +Lorsque vous régénérez le projet, la version Android dispose de la taille de police personnalisée, tandis que d'autres restent inchangés. + +Vous pouvez également utiliser `merges` pour ajouter des fichiers non présents dans le répertoire original de `www` . Par exemple, une application peut intégrer un *bouton* graphique à l'interface d'iOS, stocké dans `merges/ios/img/back_button.png`, tandis que la version Android peut au lieu de capter `ButtonBack` événements depuis le bouton matériel correspondant. + +## Aide commandes + +Cordoue possède quelques commandes globales, qui peuvent vous aider si vous êtes coincé ou rencontrez un problème. La commande `help` affiche toutes les commandes disponibles de Cordova et leur syntaxe : + + $ cordova help + $ cordova # same + + +En outre, vous pouvez obtenir une aide plus détaillée sur une commande spécifique. Par exemple : + + $ cordova run --help + + +La commande `infos` produit une liste des informations potentiellement utiles, tels que les plates-formes actuellement installés et plugins, des versions pour chaque plate-forme SDK et versions de la CLI et `node.js`: + + $ cordova info + + +Celle-ci présente l'information à l'écran et capture la sortie dans un fichier local `info.txt` . + +**NOTE**: actuellement, seuls les détails sur iOS et Android plates-formes sont disponibles. + +## Mise à jour de Cordova et votre projet + +Après l'installation de l'utilitaire de `cordova` , vous pouvez toujours mettre à jour vers la dernière version en exécutant la commande suivante : + + $ sudo npm update -g cordova + + +Utilisez cette syntaxe pour installer une version spécifique : + + $ sudo npm install -g cordova@3.1.0-0.2.0 + + +Exécutez `cordova -v` pour voir quelle version est en cours d'exécution. Exécutez la commande `npm info` pour obtenir une liste plus longue qui inclut la version actuelle ainsi que d'autres numéros de version disponible : + + $ npm info cordova + + +Cordova 3.0 est la première version à supporter l'interface de ligne de commande décrite dans cette section. Si vous mettez à jour depuis une version antérieure à 3.0, vous devez créer un nouveau projet, tel que décrit ci-dessus, puis copiez les actifs les plus âgés de l'application dans le répertoire de niveau supérieur `www` . Le cas échéant, plus amples détails au sujet de la mise à niveau vers 3.0 sont disponibles dans les [Guides de la plate-forme](../platforms/index.html). Une fois que vous passer à l'interface de ligne de commande de `cordova` et utilisez `mise à jour de la NGP` se pour tenir au courant, les plus longues procédures décrits là ne sont plus pertinentes. + +Cordova 3.0 + peut-être encore exiger des divers changements à la structure de répertoire au niveau du projet et les autres dépendances. Après avoir exécuté la commande `NGP` ci-dessus pour mettre à jour de Cordoue elle-même, vous devrez peut-être s'assurer que les ressources de votre projet sont conformes aux exigences de la version la plus récente. Exécutez une commande semblable à la suivante pour chaque plate-forme que vous générez : + + $ cordova platform update android + $ cordova platform update ios + ...etc.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/hybrid/plugins/index.md ---------------------------------------------------------------------- diff --git a/www/docs/fr/7.x/guide/hybrid/plugins/index.md b/www/docs/fr/7.x/guide/hybrid/plugins/index.md new file mode 100644 index 0000000..f76ea2f --- /dev/null +++ b/www/docs/fr/7.x/guide/hybrid/plugins/index.md @@ -0,0 +1,178 @@ +--- +license: > + Licensed to the Apache Software Foundation (ASF) under one + or more contributor license agreements. See the NOTICE file + distributed with this work for additional information + regarding copyright ownership. The ASF licenses this file + to you under the Apache License, Version 2.0 (the + "License"); you may not use this file except in compliance + with the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, + software distributed under the License is distributed on an + "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, either express or implied. See the License for the + specific language governing permissions and limitations + under the License. + +title: Guide de développement de plugin +toc_title: Create a plugin +--- + +# Guide de développement de plugin + +Un *plugin* est un ensemble de code injecté qui permet le webview Cordova, dans lequel l'application restitue pour communiquer avec la plate-forme native sur lequel il s'exécute. Plugins permettent d'accéder aux fonctionnalités de périphérique et de la plate-forme habituellement non disponible pour les applications web. Toutes les fonctionnalités principales de Cordova API sont implémentées comme des plugins, et beaucoup d'autres n'est disponibles qu'enable caractéristiques tels que les scanners de codes à barres, communication NFC, ou d'adapter le calendrier des interfaces. Il y a un [Registre][1] des plugins disponibles. + + [1]: http://plugins.cordova.io + +Plugins comportent une seule interface JavaScript ainsi que les bibliothèques de code natif correspondant pour chaque plate-forme prise en charge. En substance, cela masque les diverses implémentations de code natif derrière une interface commune de JavaScript. + +Ãtapes de cette section à un plugin simple *écho* qui transmet une chaîne à partir de JavaScript pour la plate-forme native et le retour, que vous pouvez utiliser comme modèle pour créer des fonctionnalités beaucoup plus complexes. Cette section traite de la structure du plugin de base et l'interface JavaScript donnant sur l'extérieur. Pour chaque interface native correspondante, consultez la liste à la fin de cette section. + +En plus de ces instructions, avant de commencer à écrire un plugin qu'il est préférable de chercher sur [les plugins][2] pour l'orientation. + + [2]: http://cordova.apache.org/#contribute + +## Construction d'un Plugin + +Les développeurs d'applications utilisent de la CLI `plugin add` commande (discuté dans l'Interface de ligne de commande) d'appliquer un plugin pour un projet. L'argument de cette commande est l'URL pour un dépôt *git* contenant le code du plugin. Cet exemple implémente Device API de Cordova : + + $ cordova plugin add https://git-wip-us.apache.org/repos/asf/cordova-plugin-device.git + + +Le référentiel plugin doit disposent d'un niveau supérieur `plugin.xml` fichier manifeste. Il existe de nombreuses façons de configurer ce fichier, détails pour lesquels n'existent pas dans la spécification de Plugin. Cette version abrégée de la `Device` plugin fournit un exemple simple d'utiliser un modèle : + + <?xml version="1.0" encoding="UTF-8"?> + <plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"; + id="cordova-plugin-device" version="0.2.3"> + <name>Device</name> + <description>Cordova Device Plugin</description> + <license>Apache 2.0</license> + <keywords>cordova,device</keywords> + <js-module src="www/device.js" name="device"> + <clobbers target="device" /> + </js-module> + <platform name="ios"> + <config-file target="config.xml" parent="/*"> + <feature name="Device"> + <param name="ios-package" value="CDVDevice"/> + </feature> + </config-file> + <header-file src="src/ios/CDVDevice.h" /> + <source-file src="src/ios/CDVDevice.m" /> + </platform> + </plugin> + + +Le niveau supérieur `plugin` de tag `id` attribut utilise le même format de domaine inverse pour identifier le paquet plugin que les apps à elles sont ajoutées. Le `js-module` balise spécifie le chemin d'accès à l'interface commune de JavaScript. Le `platform` balise spécifie un jeu correspondant du code natif, pour le `ios` plate-forme dans ce cas. Le `config-file` tag encapsule un `feature` tag qui est injecté dans le spécifique à la plateforme `config.xml` fichier pour sensibiliser la plate-forme de la bibliothèque de code supplémentaire. Le `header-file` et `source-file` balises spécifient le chemin d'accès aux fichiers de composant de la bibliothèque. + +## Validation d'un Plugin + +Vous pouvez utiliser le `plugman` utilitaire vérifie si le plugin est installé correctement pour chaque plate-forme. Installer `plugman` avec la commande suivante de [nÅud][3] : + + [3]: http://nodejs.org/ + + $ npm install -g plugman + + +Vous avez besoin d'un répertoire source app valides, tels que le niveau supérieur `www` répertoire inclus dans un projet de CLI-généré par défaut tel que décrit dans l'Interface de ligne de commande. S'assurer de l'application `index.html` page d'accueil de référence le nom de JavaScript interface du plugin, comme si elle était dans le même répertoire source : + + <script src="myplugin.js"></script> + + +Puis, exécutez une commande semblable à la suivante pour vérifier si les dépendances iOS chargent correctement : + + $ plugman install --platform ios --project /path/to/my/project/www --plugin /path/to/my/plugin + + +Pour plus d'informations sur `plugman` options, voir Plugman à l'aide à gérer les Plugins. Pour plus d'informations sur la façon de *Déboguer* en fait des plugins, voir interface native de chaque plate-forme figurant au bas de cette page. + +## L'Interface JavaScript + +Le code JavaScript fournit l'interface de la face, ce qui en fait peut-être la partie la plus importante du plugin. Vous structurez votre plugin JavaScript mais vous aimez, mais vous devez appeler `cordova.exec` pour communiquer avec la plate-forme native, à l'aide de la syntaxe suivante : + + cordova.exec(function(winParam) {}, + function(error) {}, + "service", + "action", + ["firstArgument", "secondArgument", 42, false]); + + +Voici comment chaque paramètre fonctionne : + +* `function(winParam) {}`: Une fonction de rappel de succès. En supposant que votre `exec` appel se termine avec succès, cette fonction s'exécute avec des paramètres que vous lui passez. + +* `function(error) {}`: Une fonction de rappel d'erreur. Si l'opération ne se termine pas avec succès, cette fonction s'exécute avec le paramètre d'erreur facultatives. + +* `"service"`: Le nom de service à appeler sur le côté natif. Cela correspond à une classe native, pour laquelle plus d'informations sont disponibles dans les guides autochtones énumérées ci-dessous. + +* `"action"`: Le nom de l'action à appeler sur le côté natif. Généralement, cela correspond à la méthode de la classe native. Consultez les guides autochtones énumérées ci-dessous. + +* `[/* arguments */]`: Un tableau d'arguments à passer dans l'environnement natif. + +## Exemples JavaScript + +Cet exemple montre une façon d'implémenter l'interface JavaScript de plugin : + + window.echo = function(str, callback) { + cordova.exec(callback, function(err) { + callback('Nothing to echo.'); + }, "Echo", "echo", [str]); + }; + + +Dans cet exemple, le plugin s'attache à la `window` d'objet comme le `echo` fonction qui appellent plugin utilisateurs comme suit : + + window.echo("echome", function(echoValue) { + alert(echoValue == "echome"); // should alert true. + }); + + +Regarder les trois derniers arguments pour le `cordova.exec` fonction. Les premiers appels du `Echo` *service*, un nom de classe. La deuxième demande la `echo` *action*, une méthode dans cette classe. Le troisième est un tableau d'arguments qui contient la chaîne echo, qui est le `window.echo` fonction du premier paramètre. + +Le rappel du succès passé dans `exec` est simplement une référence à la fonction de rappel `window.echo` prend. Si la plate-forme native déclenche le rappel de l'erreur, il simplement solliciter le rappel de succès et lui passe une chaîne par défaut. + +## Interfaces natives + +Une fois que vous définissez JavaScript pour votre plugin, vous devez compléter au moins une implémentation native. Détails pour chaque plate-forme sont énumérés ci-dessous, et chacun s'appuie sur l'exemple simple de Plugin Echo ci-dessus : + +* [Amazon Fire OS Plugins](../../platforms/amazonfireos/plugin.html) +* [Plugins Android](../../platforms/android/plugin.html) +* [iOS Plugins](../../platforms/ios/plugin.html) +* [BlackBerry 10 Plugins](../../platforms/blackberry10/plugin.html) +* [Windows Phone 8 Plugins](../../platforms/wp8/plugin.html) +* [Plugins Windows](../../platforms/win8/plugin.html) + +La plateforme de paciarelli ne supporte pas les plugins. + +## Plugins édition + +Une fois que vous développez votre plugin, vous pouvez publier et partager avec la communauté. Vous pouvez publier votre plugin sur n'importe quel `npmjs`-base de Registre, mais celle recommandée est le [Registre de la NGP][4]. S'il vous plaît lire notre [publication plugins au guide du Musée][5]. + + [4]: https://www.npmjs.com + [5]: http://plugins.cordova.io/npm/developers.html + +**NOTE**: [Cordova plugin registre][6] évolue vers un Ãtat en lecture seule. `publish`/ `unpublish` des commandes ont été retirés de la `plugman`, donc vous aurez besoin d'utiliser les commandes correspondantes de `npm` . + + [6]: https://plugins.cordova.io + +Autres développeurs puissent l'installer votre plugin automatiquement à l'aide soit de `plugman` ou de la CLI de Cordova. (Pour plus de détails sur chaque voie de développement, voir Plugman à l'aide à gérer les Plugins et l'Interface de ligne de commande). + +Pour publier un plugin sur le Registre du Musée, que vous devez suivre les étapes ci-dessous : + +* Créez votre plugin dans le fichier `package.json` : + + $ plugman createpackagejson /path/to/your/plugin + + +* publier : + + $ npm adduser # that is if you don't have an account yet + $ npm publish /path/to/your/plugin + + +C'est tout ! + +En cours d'exécution `plugman --help` répertorie les autres commandes disponibles basés sur le registre. \ No newline at end of file http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/hybrid/webviews/index.md ---------------------------------------------------------------------- diff --git a/www/docs/fr/7.x/guide/hybrid/webviews/index.md b/www/docs/fr/7.x/guide/hybrid/webviews/index.md new file mode 100644 index 0000000..56ee1aa --- /dev/null +++ b/www/docs/fr/7.x/guide/hybrid/webviews/index.md @@ -0,0 +1,33 @@ +--- +license: > + Licensed to the Apache Software Foundation (ASF) under one + or more contributor license agreements. See the NOTICE file + distributed with this work for additional information + regarding copyright ownership. The ASF licenses this file + to you under the Apache License, Version 2.0 (the + "License"); you may not use this file except in compliance + with the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, + software distributed under the License is distributed on an + "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, either express or implied. See the License for the + specific language governing permissions and limitations + under the License. + +title: Intégrer des WebViews +toc_title: Embed Cordova in native apps +--- + +# Intégrer des WebViews + +Cordova demandes sont habituellement mises en Åuvre comme un *WebView* , basée sur un navigateur, au sein de la plate-forme mobile native. Cette section montre comment, pour les plateformes, pour créer votre propre WebView, qui rendent pleinement utilise des APIs de Cordova. Vous pouvez ensuite déployer ces composants d'application Cordova ainsi que les composants natifs dans une application hybride. + +Pour déployer une WebView, vous devez être familier avec chaque environnement de programmation native. Ce qui suit fournit des instructions sur les plates-formes prises en charge : + +* [Amazon Fire OS WebViews](../../platforms/amazonfireos/webview.html) +* [Android WebViews](../../platforms/android/webview.html) +* [iOS WebViews](../../platforms/ios/webview.html) +* [Windows Phone 8,0 WebViews](../../platforms/wp8/webview.html) \ No newline at end of file http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/next/index.md ---------------------------------------------------------------------- diff --git a/www/docs/fr/7.x/guide/next/index.md b/www/docs/fr/7.x/guide/next/index.md new file mode 100644 index 0000000..2a7c260 --- /dev/null +++ b/www/docs/fr/7.x/guide/next/index.md @@ -0,0 +1,259 @@ +--- +license: > + Licensed to the Apache Software Foundation (ASF) under one + or more contributor license agreements. See the NOTICE file + distributed with this work for additional information + regarding copyright ownership. The ASF licenses this file + to you under the Apache License, Version 2.0 (the + "License"); you may not use this file except in compliance + with the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, + software distributed under the License is distributed on an + "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, either express or implied. See the License for the + specific language governing permissions and limitations + under the License. + +title: Prochaines étapes +toc_title: Next Steps +--- + +# Prochaines étapes + +Pour les développeurs qui ont une compréhension de comment utiliser le CLI de Cordova et faire utiliser des plugins, il y a quelques petites choses, vous voudrez peut-être recherche à côté de reconstruire mieux, applications de Cordova plus performant. Le document suivant fournit des conseils sur divers sujets relatifs aux meilleures pratiques, tests, mises à niveau et autres rubriques, mais n'est pas censé être prescriptif. Considérez ceci votre point de départ pour votre croissance en tant que développeur Cordova. Aussi, si vous voyez quelque chose qui peut être amélioré, Merci de [contribuer][1]! + + [1]: http://cordova.apache.org/#contribute + +Ce guide contient les rubriques suivantes : + +* Meilleures pratiques +* Gestion des mises à niveau +* Tester les applications de Cordova +* Débogage des applications de Cordova +* Interface utilisateur +* Considérations particulières +* Jonglant +* Obtention d'aide + +# Développement d'application de meilleures pratiques Cordova + +## 1) SPA est votre ami + +Tout d'abord - vos applications Cordova devraient adopter la conception SPA (Single Page Application). Vaguement défini, un SPA est une application côté client qui s'exécute à partir d'une seule demande d'une page web. L'utilisateur charge un ensemble initial de ressources (HTML, CSS et JavaScript), et plus les mises à jour (montrant une nouvelle vue, chargement de données) se fait via AJAX. Stations thermales sont couramment utilisés pour des applications plus complexes de côté client. GMail est un bon exemple de cela. Après avoir chargé GMail, vues de courrier, l'édition et organisation sont tout fait en mettant à jour le DOM au lieu de laisser effectivement la page en cours pour charger un complètement nouveau. + +Utiliser un SPA peut vous aider à organiser votre application de manière plus efficace, mais il a aussi des avantages spécifiques pour des applications de Cordova. Une application de Cordova doit attendre pour l'événement [deviceready](../../cordova/events/events.deviceready.html) au feu avant les plugins peuvent être utilisés. Si vous n'utilisez pas un SPA, et votre utilisateur clique pour passer d'une page à l'autre, vous devrez attendre pour [deviceready](../../cordova/events/events.deviceready.html) au feu encore une fois avant de vous faire utiliser un plugin. C'est facile d'oublier que votre application s'agrandit. + +Même si vous choisissez de ne pas utiliser de Cordova, création d'une application mobile sans utiliser une architecture de page unique aura des implications graves performance. C'est parce que la navigation entre les pages exigera des scripts, actifs, etc., pour être rechargé. Même si ces biens sont mis en cache, il y aura toujours des problèmes de performances. + +Exemples de bibliothèques SPA, que vous pouvez utiliser dans vos applications de Cordova sont : + +* [AngularJS][2] +* [EmberJS][3] +* [Colonne vertébrale][4] +* [Kendo UI][5] +* [Monaca][6] +* [ReactJS][7] +* [Sencha Touch][8] +* [jQuery Mobile][9] + + [2]: http://angularjs.org + [3]: http://emberjs.com + [4]: http://backbonejs.org + [5]: http://www.telerik.com/kendo-ui + [6]: http://monaca.mobi/en/ + [7]: http://facebook.github.io/react/ + [8]: http://www.sencha.com/products/touch/ + [9]: http://jquerymobile.com + +Et beaucoup, beaucoup, plus. + +## 2) considérations relatives aux performances + +Une des plus grandes erreurs qu'un nouveau développeur de Cordova peut faire est de supposer que les résultats qu'ils obtiennent sur une machine de bureau sont la même qu'ils auront sur un appareil mobile. Alors que nos appareils mobiles ont obtenu plus puissante chaque année, ils manquent encore de la puissance et les performances d'un ordinateur de bureau. Les appareils mobiles ont généralement beaucoup moins de RAM et un GPU qui est bien loin de leur bureau (ou même un ordinateur portable) frères. Une liste complète des conseils ici serait trop, mais voici quelques petites choses à garder à l'esprit (avec une liste de ressources plus longtemps à la fin de poursuivre les recherches). + +**Cliquez sur versus Touch** - l'erreur plus grande et la plus simple, vous pouvez faire est d'utiliser les événements click. Alors que ces « » très bien fonctionnent sur mobile, la plupart des périphériques imposent un délai de 300 ms sur eux afin de distinguer entre un contact et un événement de "tenir" touch. à l'aide de `touchstart` , ou `touchend` , se traduira par une amélioration spectaculaire - 300ms ne ressemble beaucoup, mais elle peut aboutir à des mises à jour de l'interface utilisateur et le comportement saccadé. Vous devriez également considérer le fait que « toucher » les événements ne sont pas supportés dans les navigateurs non-webkit, voir [CanIUse][10]. Pour remédier à ces limitations, vous pouvez commander différentes bibliothèques comme HandJS et Fastouch. + + [10]: http://caniuse.com/#search=touch + +**Transitions CSS par rapport à la Manipulation du DOM** - utilisant l'accélération matérielle des transitions CSS sera nettement meilleure que l'utilisation de JavaScript pour créer des animations. Voir la liste des ressources à la fin de cette section pour obtenir des exemples. + +**Sucer des réseaux** - réseaux, Ok ne toujours sucer, mais la latence des réseaux mobiles, même de bons réseaux de téléphonie mobile, est bien pire que vous pensez probablement. Une application de bureau qui slurps bas 500 lignes de données JSON, toutes les 30 secondes, seront les deux plus lent sur un appareil mobile comme un gros mangeur de batterie. Gardez à l'esprit que les applications de Cordova ont plusieurs façons pour rendre persistantes les données dans l'application (LocalStorage et le système de fichiers, par exemple). Mettre en cache les données localement et être conscient de la quantité de données que vous envoyez en arrière. Il s'agit d'une considération particulièrement importante lorsque votre application est connectée via un réseau cellulaire. + +**Ressources et Articles de performances supplémentaires** + +* [« Vous la moitié cul il »][11] +* [« Top dix conseils de Performance pour PhoneGap et hybride Apps »][12] +* [« Des applications rapides et des Sites avec JavaScript »][13] + + [11]: http://sintaxi.com/you-half-assed-it + [12]: http://coenraets.org/blog/2013/10/top-10-performance-techniques-for-phonegap-and-hybrid-apps-slides-available/ + [13]: https://channel9.msdn.com/Events/Build/2013/4-313 + +## 3) reconnaître et gérer l'état hors connexion + +Voir le Conseil précédent sur les réseaux. Non seulement vous pouvez être sur un réseau lent, il est tout à fait possible pour votre application d'être complètement déconnecté. Votre application doit gérer cela de manière intelligente. Si votre application ne fonctionne pas, les gens penseront que votre application est cassée. Vu comment il est facile à manipuler (supports de Cordova à l'écoute pour un événement à la fois en ligne et hors ligne), il n'y a absolument aucune raison pour que votre application ne répond ne pas bien quand exécuter en mode hors connexion. Veillez à tester (voir la section tests ci-dessous) votre demande et n'oubliez pas de tester comment votre application gère quand vous commencez dans un Ãtat et ensuite passez à l'autre. + +Notez que les événements en ligne et hors ligne, ainsi que l'API de connexion de réseau n'est pas parfait. Vous devrez compter sur via une requête XHR afin de déterminer si l'appareil est vraiment hors ligne ou en ligne. à la fin de la journée, être bien sûr ajouter une forme d'assistance pour les problèmes de réseau - en fait, l'Apple store (et probablement d'autres magasins) rejettera les applications qui ne gèrent correctement les Ãtats hors ligne/en ligne. Pour plus d'informations sur ce sujet, voir ["Is This Thing sur?"][14] + + [14]: http://blogs.telerik.com/appbuilder/posts/13-04-23/is-this-thing-on-%28part-1%29 + +# Gestion des mises à niveau + +## La mise à niveau de projets de Cordova + +Si votre projet existant a été créé à l'aide de Cordova 3.x, vous pouvez mettre à niveau le projet en émettant ce qui suit : + + Cordova plate-forme mise à jour-nom de la plate-forme ios, android, etc. + + +Si votre projet existant a été créé sous une version antérieure à Cordova 3.x, il serait probablement préférable de créer un nouveau projet de 3.x de Cordova et copiez code et les actifs de votre projet existant vers le nouveau projet. Ãtapes typiques : + +* Créez un nouveau projet de 3.x Cordova (cordova créer...) +* Copiez le dossier www de votre ancien projet vers le nouveau projet +* Copier les paramètres de configuration de l'ancien projet vers le nouveau projet +* Ajouter les plugins utilisés dans l'ancien projet vers le nouveau projet +* Générez votre projet +* Tester, tester, tester ! + +Quelle que soit la version antérieure du projet, il est absolument essentiel que vous lire sur ce qui a été changé dans la version mise à jour, car la mise à jour pourrait casser votre code. Il sera le meilleur endroit pour trouver ces informations dans les notes publiées sur le blog de Cordova tant dans les dépôts. Vous voudrez tester votre application soigneusement afin de vérifier qu'il fonctionne correctement après avoir effectué la mise à jour. + +Remarque : certains plugins n'est peut-être pas compatibles avec la nouvelle version de Cordova. Si un plugin n'est pas compatible, vous pouvez être en mesure de trouver un plugin de remplacement qui ne ce dont vous avez besoin, ou vous devrez peut-être retarder la mise à niveau de votre projet. Vous pouvez également modifier le plugin afin qu'il fonctionne en vertu de la nouvelle version et contribuer à la collectivité. + +## Mises à jour du plugin + +à partir de Cordova 3.4, il n'y a aucun mécanisme pour la mise à niveau de plugins modifiées à l'aide d'une seule commande. Au lieu de cela, supprimez le plugin et ajouter de nouveau à votre projet, et la nouvelle version sera installée : + + Cordova plugin rm com.some.plugin cordova plugin ajouter com.some.plugin + + +N'oubliez pas de vérifier la documentation de la mise à jour du plugin, que vous devrez peut-être modifier votre code pour utiliser la nouvelle version. Aussi, le double de vérifier que la nouvelle version du plugin fonctionne avec la version de votre projet de Cordova. + +Testez toujours vos applications pour faire en sorte qu'installer le nouveau plugin a cassé pas quelque chose que vous n'avez pas prévu. + +Si votre projet comporte beaucoup de plugins dont vous avez besoin de mise à jour, il pourrait gagner du temps pour créer un script shell ou le lot qui supprime et ajoute les plugins avec une seule commande. + +# Tester les applications de Cordova + +Il est super important de tester vos applications. L'équipe de Cordova utilise Jasmine mais toute solution de test web convivial unité va faire. + +## Test sur un simulateur vs sur un périphérique réel + +Il n'est pas rare d'utiliser les navigateurs de bureau et de simulateurs/émulateurs de périphérique lors du développement d'une application de Cordova. Toutefois, il est extrêmement important que vous testiez votre application sur les périphériques physiques autant que vous le pouvez : + +* Les simulateurs sont exactement cela : simulateurs. Par exemple, votre application peut fonctionner dans le simulateur iOS sans problème, mais il peut échouer sur un périphérique réel (en particulier dans certaines circonstances, comme un état de manque de mémoire). Ou, votre application peut ne pas réellement sur le simulateur alors qu'il fonctionne très bien sur un périphérique réel. +* Ãmulateurs sont que cela : émulateurs. Ils ne représentent pas bien votre application s'exécute sur un périphérique physique. Par exemple, certains émulateurs peuvent rendre votre application avec un affichage brouillé, alors qu'un véritable appareil n'a aucun problème. (Si vous ne rencontrez pas ce problème, désactivez l'hôte GPU dans l'émulateur.) +* Les simulateurs sont généralement plus rapides que votre périphérique physique. En revanche, les émulateurs, sont généralement plus lentes. Ne jugez pas les performances de votre application de comment il se comporte dans un simulateur ou un émulateur. Ne jugez pas les performances de votre application de comment il fonctionne sur un éventail de dispositifs réels. +* Il est impossible d'avoir une bonne idée de comment votre application répond à votre contact à l'aide d'un simulateur ou un émulateur. Au lieu de cela, l'application en cours d'exécution sur un périphérique réel peut signaler des problèmes avec les tailles des éléments d'interface utilisateur, réactivité, etc.. +* Bien qu'il serait agréable de pouvoir tester uniquement sur un périphérique par la plate-forme, il est préférable de tester sur de nombreux appareils sportifs de nombreuses versions OS. Par exemple, ce qui fonctionne sur votre smartphone Android particulière peut échouer sur un autre appareil Android. Ce qui fonctionne sur un appareil iOS 7 peut échouer sur un appareil iOS 6. + +Il est, bien sûr, impossible de tester sur chaque dispositif possible sur le marché. Pour cette raison, il est sage de recruter de nombreux testeurs qui ont différents périphériques. Bien qu'ils n'attrapent pas tous les problèmes, les chances sont bonnes qu'ils découvriront les bizarreries et les questions que vous trouveriez jamais seul. + +Astuce : Il est possible sur les appareils Android Nexus pour flasher facilement différentes versions d'Android sur le périphérique. Ce procédé simple vous permettra de facilement tester votre application sur différents niveaux d'Android avec un seul appareil, sans annulation de votre garantie ou vous obligeant à « jailbreak » ou « racine » de votre appareil. Les images de Google Android usine et les instructions situent trouve à : https://developers.google.com/android/nexus/images#instructions + +# Débogage des applications de Cordova + +Débogage Cordova nécessite certaine configuration. Contrairement à une application de bureau, vous ne pouvez pas simplement ouvrir outils sur votre appareil mobile et démarrez le débogage, heureusement il y a des alternatives beaucoup. + +## iOS débogage + +### Xcode + +Avec Xcode, vous pouvez déboguer le côté natif iOS de votre application de Cordova. Assurez-vous que la zone Debug est montrant (vue-> zone Debug). Une fois que votre application s'exécute sur l'appareil (ou simulateur), vous pouvez afficher la sortie du journal dans la zone de débogage. C'est où des erreurs ou des avertissements seront imprimera. Vous pouvez également définir des points d'arrêt dans les fichiers source. Cela vous permettra de parcourir le code une ligne à la fois et d'afficher l'état des variables à cette époque. L'état des variables apparaît dans la zone de débogage lorsqu'un point d'arrêt est atteint. Une fois que votre application est en cours d'exécution sur le périphérique, vous pouvez faire apparaître inspecteur web de Safari (comme décrit ci-dessous) pour déboguer le côté webview et js de votre application. Pour plus d'informations et d'aide, consultez le guide de Xcode : [Guide de débogage de Xcode][15] + + [15]: https://developer.apple.com/library/mac/documentation/ToolsLanguages/Conceptual/Xcode_Overview/DebugYourApp/DebugYourApp.html#//apple_ref/doc/uid/TP40010215-CH18-SW1 + +### Distance de Safari débogage avec Web Inspector + +Avec l'inspecteur web de Safari, vous pouvez déboguer le code webview et js dans votre application de Cordova. Cela fonctionne seulement sur OSX et qu'avec iOS 6 (et versions ultérieures). Il utilise Safari pour vous connecter à votre appareil (ou le simulateur) et reliera les outils du navigateur à la demande de Cordova. Vous obtenez ce que vous attendez d'outils / DOM inspection/manipulation, un débogueur JavaScript, inspection de réseau, la console et plus. Comme Xcode, avec l'inspecteur web de Safari, vous pouvez définir des points d'arrêt dans le code JavaScript et afficher l'état des variables à cette époque. Vous pouvez afficher les erreurs, des avertissements ou des messages qui sont affichés dans la console. Vous pouvez également exécuter des commandes JavaScript directement à partir de la console, que votre application s'exécute. Pour plus de détails sur la façon de mettre en place et ce que vous pouvez faire, voir cet excellent blog : <http://moduscreate .com/enable-remote-web-inspector-in-ios-6/> et ce guide : [Guide de Safari Web Inspector][16] + + [16]: https://developer.apple.com/library/safari/documentation/AppleApplications/Conceptual/Safari_Developer_Guide/Introduction/Introduction.html + +## Débogage distant chrome + +Pratiquement identique à la version de Safari, cela fonctionne seulement avec Android, mais peut être utilisé à partir de n'importe quel système d'exploitation. Il nécessite un minimum de 4,4 Android (KitKat), niveau API minimum de 19 et Chrome 30 + (sur le bureau). Une fois connecté, vous obtenez la même expérience de Chrome Dev Tools pour vos applications mobiles comme vous le faites avec vos applications de bureau. Mieux encore, les outils de Dev Chrome ont une option de miroir qui montre votre application en cours d'exécution sur le périphérique mobile. C'est plus qu'un avis - vous pouvez faire défiler et cliquez sur à partir des outils de dev et il met à jour sur le périphérique mobile. Plus d'informations sur le débogage distant de Chrome peuvent être trouvés ici : <https://developers.google.com/chrome/mobile/docs/debugging> + +Il est possible d'utiliser Chrome Dev Tools pour inspecter les applications iOS, à travers un proxy WebKit : <https://github.com/google/ios-webkit-debug-proxy/> + +## Ondulation + +Ondulation est un émulateur basé fonds pour projets de Cordova. Essentiellement, il vous laisse exécuter une application de Cordova dans votre application cliente et de faux diverses fonctionnalités de Cordova. Par exemple, il vous permet de simuler l'accéléromètre pour tester le shake événements. Il faux la caméra API en vous permettant de sélectionner une image depuis votre disque dur. Ondulation permet de que vous concentrerez davantage sur votre code personnalisé, plutôt que de vous inquiéter au sujet des plugins de Cordova. Vous pouvez en savoir plus sur l'ondulation ici : <http://ripple.incubator.apache.org/> + +## Weinre + +Weinre crée un serveur local qui peut héberger un client de débogage distant pour vos applications de Cordova. Après avoir installé et démarré il vers le haut, vous copiez une ligne de code dans votre application de Cordova et puis redémarrez. Vous pouvez alors ouvrir un panel d'outil de dev sur votre bureau pour travailler avec l'application. Weinre n'est pas tout à fait aussi fantaisie comme le Chrome et le débogage distant Safari mais a l'avantage de travailler avec un beaucoup plus grand nombre de plates-formes et de systèmes d'exploitation. Plus d'informations peuvent être trouvées ici : <http://people.apache.org/~pmuellr/weinre/docs/latest/> + +## Autres Options + +* BlackBerry 10 prend en charge le débogage ainsi : [Documentation][17] +* Vous pouvez déboguer à l'aide de Firefox App Manager aussi bien, voir [ce blog][18] et cet [article MDN][19]. +* Pour plus d'exemples et d'explication des conseils ci-dessus de débogage, consultez : <http://developer.telerik.com/featured/a-concise-guide-to-remote-debugging-on-ios-android-and-windows-phone/> + + [17]: https://developer.blackberry.com/html5/documentation/v2_0/debugging_using_web_inspector.html + [18]: https://hacks.mozilla.org/2014/02/building-cordova-apps-for-firefox-os/ + [19]: https://developer.mozilla.org/en-US/Apps/Tools_and_frameworks/Cordova_support_for_Firefox_OS#Testing_and_debugging + +# Interface utilisateur + +Création d'une application de Cordoue qui est très joli sur mobile peut être un défi, surtout pour les développeurs. Beaucoup de gens ont choisi d'utiliser une infrastructure d'interface utilisateur pour faciliter cette opération. Voici une courte liste des options, que vous voudrez peut-être. + +* [jQuery Mobile][9] - jQuery Mobile améliore automatiquement votre mise en page pour l'optimisation des mobile. Il gère également la création d'un SPA pour vous automatiquement. +* [ionique][20] -cette infrastructure d'interface utilisateur puissante a fait son propre indicateur composite avancé pour gérer la création d'un projet. +* [Ratchet][21] - présentée par les personnes qui ont créé le Bootstrap. +* [Kendo UI][5] - interface Open source et applicative de Telerik. +* [Couche de finition][22] +* [ReactJS][7] + + [20]: http://ionicframework.com/ + [21]: http://goratchet.com/ + [22]: http://topcoat.io + +Lorsque vous générez votre interface utilisateur, il est important de penser à toutes les plateformes que vous ciblez et les différences entre les attentes de l'utilisateur. Par exemple, une application Android qui a une interface style iOS ira probablement pas plus de bien avec les utilisateurs. C'est parfois même appliquée par les divers magasins de l'application. Pour cette raison, il est important de respecter les conventions de chaque plateforme et sont donc familiers avec les différentes directives d'Interface humaine : + +* [iOS][23] +* [Androïde][24] +* [Windows Phone][25] + + [23]: https://developer.apple.com/library/ios/documentation/userexperience/conceptual/MobileHIG/index.html + [24]: https://developer.android.com/designWP8 + [25]: http://dev.windowsphone.com/en-us/design/library + +## Ressources et Articles d'interface utilisateur supplémentaires + +Bien que le navigateur moteurs deviennent plainte de normes de plus en plus, nous vivons encore dans un monde avec des préfixes (-webkit et - Mme) l'article suivant est utile lors du développement de l'interface utilisateur dans des Croix navigateur apps: <http://blogs.windows.com/windows_phone/b/wpdev/archive/2012/11/15/adapting-your-webkit-optimized-site-for-internet-explorer-10.aspx> + +# Considérations particulières + +Bien que Cordova facilite le développement interplate-forme, c'est juste pas possible d'assurer une isolation 100 % de la plate-forme native sous-jacente. Il ne faut pas être au courant des restrictions. + +## Bizarreries de la plate-forme + +En lisant la documentation, chercher des sections qui décrivent les exigences sur plusieurs plates-formes ou des comportements différents. S'il est présent, il s'agit dans une section intitulée « Bizarreries Android », « iOS Quirks », etc.. Lisez ces bizarreries et être conscients d'eux pendant que vous travaillez avec Cordova. + +## Chargement du contenu distant + +Appel de fonctions de Cordova JavaScript d'une page HTML de chargement à distance (une page HTML ne pas stockée localement sur l'appareil) est une configuration non prise en charge. C'est parce que Cordova n'a pas été conçu pour cela, et la communauté Apache Cordova ne fait aucun test de cette configuration. Même si elle peut fonctionner dans certaines circonstances, il n'est pas recommandé ni pris en charge. Il existe des défis avec la stratégie de même origine, gardant le JavaScript et portions natives de Cordova synchronisées à la même version (puisqu'ils sont couplés via API privé qui peut changer), la fiabilité du contenu distant en appelant les fonctions locales natives et potentiels app store rejet. + +L'affichage du chargement à distance HTML contenu dans une webview devrait être fait à l'aide de InAppBrowser de Cordova. Le InAppBrowser est conçu pour que JavaScript exécutant il n'a pas accès aux APIs JavaScript Cordova pour les raisons énumérées ci-dessus. Veuillez consulter le Guide de la sécurité. + +# Jonglant + +Voici quelques façons de tenir à jour avec Cordova. + +* S'abonner au [blog de Cordova][26]. +* S'abonner à la [liste des développeurs][27]. Note - ce n'est pas un groupe de soutien ! Plutôt, c'est un endroit où le développement de Cordova est discutée. + + [26]: http://cordova.apache.org/#news + [27]: http://cordova.apache.org/#mailing-list + +# Obtention d'aide + +Les liens suivants sont les meilleurs endroits pour obtenir de l'aide pour Cordova : + +* StackOverflow : <http://stackoverflow.com/questions/tagged/cordova> à l'aide de la balise de Cordova, vous pouvez afficher et parcourir toutes les questions de Cordova. Notez que StackOverflow convertit automatiquement le tag « Phonegap » à « Cordova », sorte de cette façon, vous serez en mesure d'accéder aux questions historiques aussi bien +* PhoneGap Google Group : [https://groups.google.com/forum/#! forum/phonegap][28] ce groupe de Google a été l'ancien forum de soutien lorsque Cordova s'appelait encore PhoneGap. Bien qu'il existe encore beaucoup d'utilisateurs de Cordoue qui fréquentent ce groupe, la communauté de Cordova a exprimé un intérêt en se concentrant moins sur ce groupe et à la place utiliser StackOverflow pour un support +* Meetup : <http://phonegap.meetup.com> - pensez à trouver un groupe local de meetup Cordova/PhoneGap + + [28]: https://groups.google.com/forum/#!forum/phonegap http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/overview/index.md ---------------------------------------------------------------------- diff --git a/www/docs/fr/7.x/guide/overview/index.md b/www/docs/fr/7.x/guide/overview/index.md new file mode 100644 index 0000000..421b144 --- /dev/null +++ b/www/docs/fr/7.x/guide/overview/index.md @@ -0,0 +1,78 @@ +--- +license: > + Licensed to the Apache Software Foundation (ASF) under one + or more contributor license agreements. See the NOTICE file + distributed with this work for additional information + regarding copyright ownership. The ASF licenses this file + to you under the Apache License, Version 2.0 (the + "License"); you may not use this file except in compliance + with the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, + software distributed under the License is distributed on an + "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, either express or implied. See the License for the + specific language governing permissions and limitations + under the License. + +title: Présentation +toc_title: Overview +--- + +# Présentation + +Apache Cordova est un framework de développement mobile open-source. Il permet d'exploiter les technologies Web courantes telles que HTML5, CSS3 et JavaScript pour développer des applications multi-plateformes, évitant ainsi l'utilisation des langages natifs propres aux différentes plates-formes mobiles. Les applications s'exécutent dans des wrappers ciblés pour chaque plate-forme, elles s'appuient sur des API conformes aux standards permettant l'accès aux capteurs de chaque appareil, aux données ainsi qu'à l'état du réseau. + +Apache Cordova a obtenu son diplôme en octobre 2012 comme un projet de niveau supérieur au sein de l'Apache Software Foundation (ASF). Par le biais de l'ASF, développement futur de Cordova assurera intendance ouvert du projet. Il restera toujours gratuit et open source sous Apache License, Version 2.0. Visitez [cordova.apache.org][1] pour plus d'informations. + + [1]: http://cordova.apache.org + +Utiliser Apache Cordova, si vous êtes : + +* un développeur mobile et que vous voulez étendre une application à plusieurs plates-formes sans avoir à réimplémenter celle-ci dans chacun des langages et avec chacun des outils propres aux différentes plates-formes. + +* un développeur Web et que vous souhaitez déployer une application Web prête à être distribuée dans divers portails de vente d'applications. + +* un développeur de mobile intéressé par la combinaison de composants de l'application native avec une *WebView* (fenêtre de navigateur spécial) qui peut accéder aux API de niveau périphérique, ou si vous voulez développer une interface plugin entre les autochtones et les composants WebView. + +## Composants de base + +Apache Cordova applications s'appuient sur un commun `config.xml` fichier qui fournit des informations sur l'application et spécifie les paramètres qui affectent comment ça marche, comme si elle répond à l'orientation se déplace. Ce fichier respecte [Emballés Web App][2]ou *widget*, spécification de la W3C. + + [2]: http://www.w3.org/TR/widgets/ + +L'application elle-même est implémentée comme une page web, par défaut, un fichier local nommé *index.html*, qui fait référence à quelque CSS, JavaScript, images, fichiers multimédias ou autres ressources sont nécessaires pour son exécution. L'application s'exécute sous une *WebView* dans le wrapper de l'application native, qui vous distribuez à l'app store. + +Le WebView Cordova-activé peut prévoir l'application grâce à son interface utilisateur entière. Sur certaines plateformes, il peut aussi être un composant dans une application hybride plus grande, qui mêle le mode Web avec des composants de l'application native. (Voir intégration WebViews pour plus de détails.) + +Une interface *plugin* est disponible pour Cordova et les composants natifs de communiquer entre eux. Cela vous permet d'invoquer le code natif de JavaScript. Idéalement, les API JavaScript que code natif concordent sur de multiples plates-formes de périphérique. Depuis la version 3.0, plugins fournir des liaisons de périphérique standard API. Plugins tiers fournissent des liaisons supplémentaires aux fonctionnalités n'est pas nécessairement disponibles sur toutes les plateformes. Vous pouvez trouver ces plugins tierce partie dans le [Registre du plugin][3] et les utiliser dans votre application. Vous pouvez également développer vos propres plugins, comme décrit dans le Guide de développement de Plugin. Plugins peut être nécessaire, par exemple, pour communiquer entre Cordoue et les composants natifs personnalisés. + + [3]: http://plugins.cordova.io + +**NOTE**: depuis la version 3.0, lorsque vous créez un projet de Cordova, il n'a pas les plugins présents. C'est le nouveau comportement par défaut. Les plugins que vous désirez, même les plugins de base, doivent être ajoutés explicitement. + +Cordova ne fournit pas les widgets de l'interface utilisateur ou cadres de MV. Cordova fournit seulement le runtime dans lequel ceux qui peuvent s'exécuter. Si vous souhaitez utiliser les widgets de l'interface utilisateur et/ou un cadre MV *, vous devrez sélectionner celles et les inclure dans votre demande vous-même comme matériel de tierces parties. + +## Voies de développement + +Depuis la version 3.0, vous pouvez utiliser deux workflows de base pour créer une application mobile. Alors que vous pouvez souvent utiliser un flux de travail à accomplir la même tâche, ils ont chacun des avantages : + +* **Flux de travail multi-plateforme (CLI)**: utiliser ce flux de travail si vous souhaitez que votre application pour exécuter le plus grand nombre des différents systèmes d'exploitation mobiles que possible, avec peu besoin spécifique à la plateforme de développement. Ce workflow est centrée autour de la `cordova` utilitaire, autrement connu comme le Cordova *CLI*, qui a été introduite avec le 3.0 de Cordova. La CLI est un outil de haut niveau qui vous permet d'élaborer des projets pour de nombreuses plateformes à la fois, faisant abstraction bien loin des fonctionnalités des scripts shell de niveau inférieur. La CLI copie un ensemble commun de ressources web dans des sous-répertoires pour chaque plate-forme mobile, apporte des changements de configuration nécessaires pour chacun, s'exécute les scripts de compilation pour générer les fichiers binaires d'application. La CLI fournit également une interface commune pour appliquer des plugins pour votre applicatio n. Pour plus de détails sur la CLI, consultez l'Interface de ligne de commande. Sauf si vous avez un besoin pour le flux de travail axée sur la plate-forme, le flux de travail multi-plateforme est recommandé. + +* **Flux de travail axée sur la plate-forme**: utilisez ce flux de travail si vous voulez mettre l'accent sur la construction d'une application pour une plateforme unique et doivent être en mesure de le modifier à un niveau inférieur. Vous devez utiliser cette approche, par exemple, si vous souhaitez que votre application pour mélanger les composants natifs personnalisés avec des composants de Cordoue sur le web, tel que discuté dans l'intégration WebViews. En règle générale, utilisez ce flux de travail si vous devez modifier le projet dans le SDK. Ce flux de travail s'appuie sur un ensemble de scripts shell de niveau inférieur qui sont adaptés pour chaque plate-forme prise en charge et un utilitaire distinct de Plugman qui vous permet d'appliquer des plugins. Alors que vous pouvez utiliser ce flux de travail pour créer des applications multi-plateformes, il est généralement plus difficile parce que l'absence d'un outil de niveau supérieur signifie cycles distinct s construction et modifications de plugin pour chaque plate-forme. Pourtant, ce flux de travail vous permet un meilleur accès à des options de développement fournis par chaque SDK et est essentiel pour les applications hybrides complexes. Voir les différents Guides de plate-forme pour plus de détails sur les utilitaires de coquille disponible de chaque plateforme. + +Lors du premier démarrage, il peut être plus facile d'utiliser le flux de travail multi-plateforme pour créer une application, tel que décrit dans l'Interface de ligne de commande. Vous avez alors la possibilité de passer à un flux de travail axée sur la plate-forme si vous avez besoin du contrôle que le SDK fournit. Utilitaires shell de niveau inférieur sont disponibles à [cordova.apache.org][1] dans une distribution distincte que le CLI. Pour les projets initialement générés par la CLI, ces outils de coquille sont également disponibles dans le projet de divers `platforms/*/cordova` répertoires. + +**Remarque**: une fois que vous passez dans le flux de travail axée sur la CLI à l'une centrée sur les kits de développement logiciel spécifique à la plateforme et les outils de shell, vous ne pouvez pas revenir en arrière. La CLI maintient un ensemble de code source multi-plateforme qui, sur chacun, générez-le utilisations d'écrire plus de code source spécifique à la plateforme. Pour conserver les modifications que vous apportez aux actifs spécifiques à la plate-forme, vous devez basculer vers les outils axés sur la plate-forme de shell, qui ignorent le code source multi-plateforme, et au contraire s'appuie sur le code source spécifique à la plateforme. + +## Installation Cordova + +L'installation de Cordova diffèrera selon le flux de travail ci-dessus que vous choisissez : + +* Flux de travail multi-plateforme : Voir l'Interface de ligne de commande. + +* Flux de travail axée sur la plate-forme : consultez les [Guides de la plate-forme](../platforms/index.html). + +Après l'installation de Cordova, il est recommandé de consulter les [Guides de la plate-forme](../platforms/index.html) pour les plates-formes mobiles qui vous mettra au point pour. Il est également recommandé que vous examiniez également le [Guide de la vie privée](../appdev/privacy/index.html), sécurité Guide et prochaines étapes. Pour la configuration de Cordova, consultez le fichier config.xml File. Pour accéder à une fonction native sur un périphérique de JavaScript, consultez le Plugin APIs. Et consulter les autres guides inclus tel qu'il est nécessaire. http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/platforms/amazonfireos/config.md ---------------------------------------------------------------------- diff --git a/www/docs/fr/7.x/guide/platforms/amazonfireos/config.md b/www/docs/fr/7.x/guide/platforms/amazonfireos/config.md new file mode 100644 index 0000000..d8fb56e --- /dev/null +++ b/www/docs/fr/7.x/guide/platforms/amazonfireos/config.md @@ -0,0 +1,71 @@ +--- +license: > + Licensed to the Apache Software Foundation (ASF) under one + or more contributor license agreements. See the NOTICE file + distributed with this work for additional information + regarding copyright ownership. The ASF licenses this file + to you under the Apache License, Version 2.0 (the + "License"); you may not use this file except in compliance + with the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, + software distributed under the License is distributed on an + "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, either express or implied. See the License for the + specific language governing permissions and limitations + under the License. + +title: Amazon Fire OS Configuration +--- + +# Amazon Fire OS Configuration + +Le `config.xml` fichier contrôle des paramètres de base de l'application s'appliquent à chaque demande et chaque instance de CordovaWebView. Cette préférences de détails section s'appliquant uniquement aux OS feu Amazon s'appuie. Voir [le fichier config.xml File][1] pour plus d'informations sur les options de configuration globale. + + [1]: config_ref_index.md.html#The%20config.xml%20File + +* `KeepRunning`(boolean, la valeur par défaut `true` ): détermine si l'application reste en cours d'exécution en arrière-plan même après une `[pause](../../../cordova/events/events.pause.html)` événement se déclenche. Affectation de `false` ne tue pas l'appli après un `[pause](../../../cordova/events/events.pause.html)` événement, mais simplement s'arrête l'exécution du code dans le webview cordova, tandis que l'application est en arrière-plan. + + <preference name="KeepRunning" value="false"/> + + +* `ErrorUrl`(URL, valeur par défaut est `null` ): si défini, affichera la page référencée sur une erreur dans l'application au lieu d'un dialogue avec le titre « Erreur d'Application ». + + <preference name="ErrorUrl" value="error.html"/> + + +* `LoadingDialog`(string, la valeur par défaut `null` ): si ensemble, affiche un dialogue avec le titre spécifié et le message et d'une fileuse, lors du chargement de la première page d'une application. Le titre et le message sont séparés par une virgule dans cette chaîne de valeur, et cette virgule est supprimée avant que la boîte de dialogue s'affiche. + + <preference name="LoadingDialog" value="Please wait, the app is loading"/> + + +* `LoadingPageDialog`(string, la valeur par défaut `null` ): le même que `LoadingDialog` , mais pour le chargement de chaque page après la première page de l'application. + + <preference name="LoadingPageDialog" value="Please wait, the data is loading"/> + + +* `LoadUrlTimeoutValue`(nombre, valeur par défaut est `20000` ): lors du chargement d'une page, la quantité de temps à attendre avant de lancer une erreur de délai d'attente. Cet exemple spécifie les 10 secondes au lieu de 20 : + + <preference name="LoadUrlTimeoutValue" value="10000"/> + + +* `SplashScreen`: Le nom du fichier moins son extension dans le `res/drawable` répertoire. Divers éléments d'actif doivent partager ce nom commun dans les différents sous-répertoires. + + <preference name="SplashScreen" value="splash"/> + + +* `SplashScreenDelay`(numéro, par défaut, `5000` ): affiche de l'image de l'écran splash le laps de temps. + + <preference name="SplashScreenDelay" value="10000"/> + + +* `ShowTitle`(boolean, la valeur par défaut `false` ): montrer le titre en haut de l'écran. + + <preference name="ShowTitle" value="true"/> + + +* `LogLevel`(string, la valeur par défaut `ERROR` ): définit le niveau de journalisation minimale par le biais de quel journal messages depuis votre application seront filtrées. Les valeurs valides sont `ERROR` , `WARN` , `INFO` , `DEBUG` , et`VERBOSE`. + + <preference name="LogLevel" value="VERBOSE"/> \ No newline at end of file --------------------------------------------------------------------- To unsubscribe, e-mail: commits-unsubscr...@cordova.apache.org For additional commands, e-mail: commits-h...@cordova.apache.org
