You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by st...@apache.org on 2016/01/28 19:10:57 UTC
[20/51] [abbrv] [partial] docs commit: added cordova 6.0.0 docs
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/fr/6.0.0/guide/hybrid/plugins/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/hybrid/plugins/index.md b/www/docs/fr/6.0.0/guide/hybrid/plugins/index.md
new file mode 100644
index 0000000..0372e09
--- /dev/null
+++ b/www/docs/fr/6.0.0/guide/hybrid/plugins/index.md
@@ -0,0 +1,177 @@
+---
+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
+---
+
+# 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/a201cf64/www/docs/fr/6.0.0/guide/hybrid/webviews/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/hybrid/webviews/index.md b/www/docs/fr/6.0.0/guide/hybrid/webviews/index.md
new file mode 100644
index 0000000..586eed7
--- /dev/null
+++ b/www/docs/fr/6.0.0/guide/hybrid/webviews/index.md
@@ -0,0 +1,32 @@
+---
+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
+---
+
+# 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/a201cf64/www/docs/fr/6.0.0/guide/next/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/next/index.md b/www/docs/fr/6.0.0/guide/next/index.md
new file mode 100644
index 0000000..f711964
--- /dev/null
+++ b/www/docs/fr/6.0.0/guide/next/index.md
@@ -0,0 +1,258 @@
+---
+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
+---
+
+# 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 plug-ins 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 plug-ins 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
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/fr/6.0.0/guide/overview/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/overview/index.md b/www/docs/fr/6.0.0/guide/overview/index.md
new file mode 100644
index 0000000..b73b18f
--- /dev/null
+++ b/www/docs/fr/6.0.0/guide/overview/index.md
@@ -0,0 +1,77 @@
+---
+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
+---
+
+# 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 plug-ins présents. C'est le nouveau comportement par défaut. Les plug-ins 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.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/fr/6.0.0/guide/platforms/amazonfireos/config.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/platforms/amazonfireos/config.md b/www/docs/fr/6.0.0/guide/platforms/amazonfireos/config.md
new file mode 100644
index 0000000..d8fb56e
--- /dev/null
+++ b/www/docs/fr/6.0.0/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
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/fr/6.0.0/guide/platforms/amazonfireos/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/platforms/amazonfireos/index.md b/www/docs/fr/6.0.0/guide/platforms/amazonfireos/index.md
new file mode 100644
index 0000000..d2b6ab6
--- /dev/null
+++ b/www/docs/fr/6.0.0/guide/platforms/amazonfireos/index.md
@@ -0,0 +1,192 @@
+---
+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 Platform Guide
+---
+
+# Amazon Fire OS Platform Guide
+
+Ce guide montre comment configurer votre environnement de développement SDK pour déployer Cordova apps de dispositifs tels les HDX feu Kindle Amazon Fire OS.
+
+Voir ci-dessous pour plus d'informations spécifiques à la plateforme :
+
+* [Amazon Fire OS Configuration](config.html)
+* [Amazon Fire OS WebViews](webview.html)
+* [Amazon Fire OS Plugins](plugin.html)
+
+## Introduction
+
+En ciblant la plateforme Amazon Fire OS, Cordova les développeurs peuvent créer des applications web hybrides qui tirent profit du moteur web avancés intégré dans les appareils Kindle Fire. Amazon WebView API (AWV) est un runtime de dérivés chrome web exclusif à feu OS. Un remplacement rapide pour l'affichage Web qui est livré avec les appareils Android, AWV permet de créer le plus performant et plus puissant hybride web apps en fournissant un soutien pour un moteur plus rapide de JavaScript (V8), débogage distant et optimisations matérielle pour les périphériques de Kindle Fire notamment un Canvas 2D accélérée, et accéder aux fonctionnalités HTML5, ne pas pris en charge par Android construit en mode Web tels que: CSS Calc, Validation de formulaire, getUserMedia, IndexedDB, Web Workers, WebSockets et WebGL.
+
+Pour plus d'informations sur l'API d'affichage Web Amazon, s'il vous plaît voir du Portail développeur Amazon [page HTML5 hybride Apps][1]. Pour toute question sur getting started et autres soutiennent des questions, veuillez consulter le portail des développeurs Amazon [Forums - HTML5 hybride Apps][2].
+
+ [1]: https://developer.amazon.com/public/solutions/platforms/android-fireos/docs/building-and-testing-your-hybrid-app
+ [2]: http://forums.developer.amazon.com/forums/category.jspa?categoryID=41
+
+## Exigences et soutien
+
+Développement d'applications de Cordova pour Amazon Fire OS nécessite l'installation d'une variété de fichiers de support, y compris tous les éléments nécessaires pour le développement Android, ainsi que le SDK de WebView d'Amazon. Consultez la liste ci-dessous pour l'installation du système requis :
+
+* L'Interface de ligne de commande
+* [Android SDK][3]
+* [Apache Ant][4]
+* [Amazon WebView SDK][1]
+
+ [3]: http://developer.android.com/sdk/
+ [4]: http://ant.apache.org
+
+## Installation
+
+### Android SDK et Apache Ant
+
+Installer le SDK Android de [developer.android.com/sdk][3]. Dans le cas contraire vous pouvez être présentées avec un choix de l'endroit où installer le SDK, déplacer le fichier téléchargé `adt-bundle` arbre à chaque fois que vous stockez des outils de développement.
+
+Vous aurez besoin pour exécuter le gestionnaire de SDK Android ( `android` partir d'une ligne de commande) au moins une fois avant de commencer votre projet de Cordova. Assurez-vous d'installer la dernière version de l' Android SDK Tools et kit de développement logiciel de plate-forme **plus précisément le niveau API 19**. S'il vous plaît, voir [Paramétrage de votre environnement de développement][5] sur le portail des développeurs pour plus d'informations sur le paramétrage de votre environnement de développement pour les appareils Kindle Fire OS Amazon.
+
+ [5]: https://developer.amazon.com/public/resources/development-tools/ide-tools/tech-docs/01-setting-up-your-development-environment
+
+Installer l'Apache Ant construire outil en [Téléchargement une distribution binaire Ant][6], décompresser dans un répertoire, vous pouvez consulter ultérieurement. Voir le [Manuel de fourmi][7] pour plus d'informations.
+
+ [6]: http://ant.apache.org/bindownload.cgi
+ [7]: http://ant.apache.org/manual/index.html
+
+Pour les outils de ligne de commande de Cordova pour travailler, vous devez inclure le Android SDK `tools` , `platform-tools` et `apache-ant/bin` des répertoires dans votre environnement de chemin d'accès.
+
+#### Chemin d'accès de Mac/Linux
+
+Sur Mac, Linux ou autres plates-formes de type Unix, vous pouvez utiliser un éditeur de texte pour créer ou modifier le `~/.bash_profile` fichier, en ajoutant une ligne comme ci-dessous, en fonction d'où sont installés les SDK et la fourmi :
+
+ export PATH = ${chemin}: / / adt-bundle/sdk/plateforme-outils de développement: / développement/adt-bundle/sdk/tools: / développement/apache-ant/bin
+
+
+Cela expose les outils SDK dans windows terminales nouvellement ouverts. Dans le cas contraire, exécutez-le pour les rendre disponibles dans la session en cours :
+
+ $ source ~/.bash_profile
+
+
+#### Chemin d'accès Windows
+
+Pour modifier l'environnement PATH sous Windows :
+
+* Cliquez sur le menu **Démarrer** dans le coin en bas à gauche du bureau, faites un clic droit sur **ordinateur**, puis cliquez sur **Propriétés**.
+
+* Cliquez sur **Paramètres système avancés** dans la colonne de gauche.
+
+* Dans la boîte de dialogue, appuyez sur **Variables d'environnement**.
+
+* Sélectionnez la variable **PATH** et appuyer sur **modifier**.
+
+* Le chemin d'accès basé sur lequel vous avez installé le SDK et les fourmis, par exemple, ajoutez ce qui suit :
+
+ ;C:\Development\adt-bundle\sdk\platform-tools;C:\Development\adt-bundle\sdk\tools;C:\Development\apache-ant\bin
+
+
+* Enregistrez la valeur et fermez les deux boîtes de dialogue.
+
+* Vous devrez aussi activer Java. Ouvrez une invite de commandes et tapez `java` , si elle ne s'exécute pas, ajoutez l'emplacement des fichiers binaires Java à votre chemin aussi bien. Assurez-vous de JAVA_HOME % pointe vers le répertoire JDK installé. Vous devrez peut-être ajouter JAVA_HOME environnement variable séparément.
+
+ ; %JAVA_HOME%\bin
+
+
+### Amazon WebView SDK
+
+Afin de créer des applications de Cordoue à l'aide de la plateforme cible de Amazon Fire OS, vous devrez télécharger, décompresser et installer les fichiers de support d'Amazon WebView SDK. Cette étape ne devrons faire votre premier projet d'Amazon Fire OS.
+
+* Télécharger le SDK de WebView Amazon depuis [Amazon Developer Portal][1].
+
+* Copie `awv_interface.jar` du SDK téléchargé au répertoire de travail de Cordova. Créer le dossier commonlibs(shown below) si il n'existe pas :
+
+ **Mac/Linux:** `~/.cordova/lib/commonlibs/`
+
+ **Windows:** `%USERPROFILE%\.cordova\lib\commonlibs`
+
+## Créer le nouveau projet pour Amazon Fire OS
+
+Utilisation du `cordova` utilitaire de mettre en place un nouveau projet, tel que décrit dans le Cordova The Command-Line Interface. Par exemple, dans un répertoire de code source :
+
+ $ cordova create hello com.example.hello "HelloWorld"
+ $ cd hello
+ $ cordova platform add amazon-fireos
+ $ cordova build
+
+
+***Remarque :*** La première fois que la plate-forme amazon-fireos est installée sur votre système, il va télécharger les fichiers appropriés dans le répertoire de travail de Cordova, mais échouera alors qu'il manque les fichiers de support AWV SDK (voir ci-dessus). Suivez les instructions ci-dessus pour installer le `awv_interface.jar` , puis supprimer et rajouter la plate-forme amazon-fireos à votre projet. Cette étape ne devrons être fait pour le premier projet Amazon Fire OS.
+
+## Déployer sur le périphérique
+
+Pour repousser un $ $ etAPP directement sur l'appareil, assurez-vous que débogage USB est activé sur votre appareil tel que décrit sur le [Site des développeurs Android][8]et utiliser un câble mini USB à brancher sur votre système.
+
+ [8]: http://developer.android.com/tools/device.html
+
+Vous pouvez pousser l'app à l'appareil de la ligne de commande :
+
+ $ cordova exécuter amazon-fireos
+
+
+En alternance au sein d'Eclipse, cliquez droit sur le projet et choisissez **Exécuter en tant que → Application Android**.
+
+**Note**: actuellement, test via un émulateur n'est pas supporté pour Amazon WebView basé applications, en outre l'Amazone WebView API est disponible uniquement sur appareils OS feu. Pour plus d'informations, consultez la documentation de [Amazon WebView API SDK][1] .
+
+### Exécuter des drapeaux
+
+La commande exécuter accepte des paramètres optionnels comme spécifié dans le document d'Interface de ligne de commande de Cordova, feu OS accepte également un supplément `--debug` drapeau qui permettra aux outils de développement de chrome pour le débogage distant web.
+
+Pour utiliser les outils du développeur, saisissez :
+
+ $ cordova run --debug amazon-fireos
+
+
+Cela permettra à des outils sur le client en cours d'exécution. Vous pouvez ensuite connecter au client par la redirection de port en utilisant l'Android Debug pont (adb) faisant référence au nom du paquet de l'application.
+
+Par exemple :
+
+ ADB tcp:9222 avant localabstract:com.example.helloworld.devtools
+
+
+Vous pouvez ensuite utiliser le DevTools via un navigateur basé sur Chromium en accédant à :`http://localhost:9222`.
+
+### Prise en charge facultative Eclipse
+
+Une fois créé, vous pouvez utiliser l'éclipse qui est livré avec le SDK Android pour modifier le projet. Prenez garde que les modifications apportées par le biais de Eclipse seront remplacées si vous continuez à utiliser les outils de ligne de commande de Cordova.
+
+* Lancez l'application **Eclipse** .
+
+* Sélectionnez l'élément de menu **Nouveau projet** .
+
+* Choisissez **Un projet Android à partir de Code existant** dans la boîte de dialogue, puis appuyez sur **suivant**: ![][9]
+
+* Accédez à `hello` , ou n'importe quel répertoire vous avez créé pour le projet, puis à la `platforms/amazon-fireos` sous-répertoire.
+
+* Eclipse vous montrera Bonjour et Bonjour-CorddovaLib - 2 projets à ajouter. Ajoutez les deux.
+
+* Appuyez sur **Terminer**.
+
+ [9]: {{ site.baseurl }}/static/img/guide/platforms/android/eclipse_new_project.png
+
+Une fois que la fenêtre de Eclipse s'ouvre, un rouge **X** peut apparaître pour indiquer les problèmes non résolus. Dans l'affirmative, suivez ces étapes supplémentaires :
+
+* Faites un clic droit sur le répertoire du projet.
+
+* Dans la boîte de dialogue **Propriétés** , sélectionnez **Android** du volet de navigation.
+
+* Pour la cible de génération de projet, sélectionnez le plus haut niveau de Android API (actuellement API niveau 19) vous avez installé.
+
+* Cliquez sur **OK**.
+
+* Sélectionnez **nettoyer** dans le menu **projet** . Cela devrait corriger toutes les erreurs dans le projet.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/fr/6.0.0/guide/platforms/amazonfireos/plugin.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/platforms/amazonfireos/plugin.md b/www/docs/fr/6.0.0/guide/platforms/amazonfireos/plugin.md
new file mode 100644
index 0000000..b61cb77
--- /dev/null
+++ b/www/docs/fr/6.0.0/guide/platforms/amazonfireos/plugin.md
@@ -0,0 +1,106 @@
+---
+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 Plugins
+---
+
+# Amazon Fire OS Plugins
+
+Suivez les instructions fournies dans le Guide de [Plugins Android](../android/plugin.html) pour une vue d'ensemble du développement de plugins personnalisés.
+
+## Echo Amazon Fire OS Plugin exemple
+
+Pour trouver *l'écho de l'interface JavaScript décrite dans les Plugins de l'Application* , utilisez le `plugin.xml` pour injecter un `feature` spécification à de la plate-forme locale `config.xml` fichier :
+
+ <platform name="amazon-fireos">
+ <config-file target="config.xml" parent="/*">
+ <feature name="Echo">
+ <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+ </feature>
+ </config-file>
+ </platform>
+
+
+Puis ajoutez le code suivant à la `src/org/apache/cordova/plugin/Echo.java` fichier :
+
+ package org.apache.cordova.plugin;
+
+ import org.apache.cordova.CordovaPlugin;
+ import org.apache.cordova.CallbackContext;
+
+ import org.json.JSONArray;
+ import org.json.JSONException;
+ import org.json.JSONObject;
+
+ /**
+ * This class echoes a string called from JavaScript.
+ */
+ public class Echo extends CordovaPlugin {
+
+ @Override
+ public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+ if (action.equals("echo")) {
+ String message = args.getString(0);
+ this.echo(message, callbackContext);
+ return true;
+ }
+ return false;
+ }
+
+ private void echo(String message, CallbackContext callbackContext) {
+ if (message != null && message.length() > 0) {
+ callbackContext.success(message);
+ } else {
+ callbackContext.error("Expected one non-empty string argument.");
+ }
+ }
+ }
+
+
+Si vous souhaitez réutiliser le code Android Plugin pour la plateforme Amazon Fire OS puis modifier la plugin.xml pour pointer vers le `android` fichier source spécifique. Par exemple,
+
+ <platform name="amazon-fireos">
+ <config-file target="config.xml" parent="/*">
+ <feature name="Echo">
+ <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+ </feature>
+ </config-file>
+ <source-file src="src/android/Echo.java" target-dir="src/org/apache/cordova/plugin" />
+ </platform>
+
+
+Si vous voulez écrire un plugin personnalisé pour la plateforme Amazon Fire OS, puis créez un dossier nommé `amazon` dans votre plugin src / dossier et modifier la plugin.xml pour pointer vers le `amazon` fichier source spécifique. Par exemple,
+
+ <platform name="amazon-fireos">
+ <config-file target="config.xml" parent="/*">
+ <feature name="Echo">
+ <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+ </feature>
+ </config-file>
+ <source-file src="src/amazon/Echo.java" target-dir="src/org/apache/cordova/plugin" />
+ </platform>
+
+
+## À l'aide de Amazon WebView dans votre plugin
+
+Cordova pour Amazon Fire OS utilise personnalisé WebView Amazon qui repose sur le projet open source Chromium. C'est le GPU accéléré et optimisée pour des performances fluides sur Kindle Fire.
+
+Pour comprendre comment mieux utiliser Amazon WebView dans votre projet, consultez le [Portail des développeurs Amazon][1].
+
+ [1]: https://developer.amazon.com/sdk/fire/IntegratingAWV.html
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/fr/6.0.0/guide/platforms/amazonfireos/webview.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/platforms/amazonfireos/webview.md b/www/docs/fr/6.0.0/guide/platforms/amazonfireos/webview.md
new file mode 100644
index 0000000..2cebf81
--- /dev/null
+++ b/www/docs/fr/6.0.0/guide/platforms/amazonfireos/webview.md
@@ -0,0 +1,129 @@
+---
+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 WebViews
+---
+
+# Amazon Fire OS WebViews
+
+3.3.0 à partir, vous pouvez utiliser Cordova comme composant dans les applications Amazon Fire OS. Amazon Fire OS se réfère à cette composante `CordovaWebView` . `CordovaWebView`s'étend de WebView Amazon qui repose sur l'open source Chromium projet. En tirant parti de cette fonctionnalité, vos applications web peuvent utiliser les dernières normes web HTML5 s'exécutant dans un moteur d'exécution de web moderne.
+
+Si vous n'êtes pas familier avec Amazon Fire OS, vous devez tout d'abord vous familiariser avec le Guide de plateforme Amazon Fire OS et avez le dernier SDK installé avant d'essayer l'option de développement plus inhabituelle d'incorporation une WebView.
+
+## Conditions préalables
+
+* Cordova 3.3.0 ou supérieur
+
+* Android SDK mis à jour vers la dernière version du SDK
+
+* Amazon WebView SDK
+
+## Guide à l'aide de CordovaWebView dans un projet d'OS Amazon Fire
+
+1. Pour suivre ces instructions, vérifiez que vous avez la dernière distribution de Cordova. Téléchargez-le sur [cordova.apache.org][1] et décompressez son OS feu Amazon.
+
+2. Télécharger et étendre l' [Amazone WebView SDK][2] , puis copiez le awv_interface.jar en `/framework/libs` répertoire. Créer un libs / dossier s'il n'existe pas.
+
+3. Accédez à du package `/framework` répertoire et exécutez `ant jar` . Il crée le Cordova `.jar` fichier, formé comme`/framework/cordova-x.x.x.jar`.
+
+4. Copie le `.jar` fichier dans le projet Android `/libs` répertoire.
+
+5. Ajoutez le code suivant à l'application `/res/xml/main.xml` fichier, avec la `layout_height` , `layout_width` et `id` modifié en fonction de l'application :
+
+ <org.apache.cordova.CordovaWebView
+ android:id="@+id/tutorialView"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent" />
+
+
+6. Modifier votre activité de sorte qu'il met en œuvre le `CordovaInterface` . Vous devez implémenter les méthodes inclus. Vous pouvez les copier de `/framework/src/org/apache/cordova/CordovaActivity.java` , ou leur mise en œuvre sur votre propre. Le fragment de code ci-dessous montre une application qui utilise l'interface de base. Notez comment correspond à l'id de la vue référencée le `id` attribut spécifié dans le fragment XML indiqué ci-dessus :
+
+ public class CordovaViewTestActivity extends Activity implements CordovaInterface {
+ CordovaWebView cwv;
+ /* Called when the activity is first created. */
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.main);
+ cwv = (CordovaWebView) findViewById(R.id.tutorialView);
+ Config.init(this);
+ cwv.loadUrl(Config.getStartUrl());
+ }
+
+
+ [1]: http://cordova.apache.org
+ [2]: https://developer.amazon.com/sdk/fire/IntegratingAWV.html#installawv
+
+Si vous utilisez l'appareil photo, vous devez également implémenter ceci :
+
+ @Override
+ public void setActivityResultCallback(CordovaPlugin plugin) {
+ this.activityResultCallback = plugin;
+ }
+ /**
+ * Launch an activity for which you would like a result when it finished. When this activity exits,
+ * your onActivityResult() method is called.
+ *
+ * @param command The command object
+ * @param intent The intent to start
+ * @param requestCode The request code that is passed to callback to identify the activity
+ */
+ public void startActivityForResult(CordovaPlugin command, Intent intent, int requestCode) {
+ this.activityResultCallback = command;
+ this.activityResultKeepRunning = this.keepRunning;
+
+ // If multitasking turned on, then disable it for activities that return results
+ if (command != null) {
+ this.keepRunning = false;
+ }
+
+ // Start activity
+ super.startActivityForResult(intent, requestCode);
+ }
+
+ @Override
+ /**
+ * Called when an activity you launched exits, giving you the requestCode you started it with,
+ * the resultCode it returned, and any additional data from it.
+ *
+ * @param requestCode The request code originally supplied to startActivityForResult(),
+ * allowing you to identify who this result came from.
+ * @param resultCode The integer result code returned by the child activity through its setResult().
+ * @param data An Intent, which can return result data to the caller (various data can be attached to Intent "extras").
+ */
+ protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
+ super.onActivityResult(requestCode, resultCode, intent);
+ CordovaPlugin callback = this.activityResultCallback;
+ if (callback != null) {
+ callback.onActivityResult(requestCode, resultCode, intent);
+ }
+ }
+
+
+Enfin, n'oubliez pas d'ajouter le pool de threads, sinon les plugins n'ont aucun thread d'exécuter sur :
+
+ @Override
+ public ExecutorService getThreadPool() {
+ return threadPool;
+ }
+
+
+1. Copiez les fichiers HTML et JavaScript de votre application dans votre projet Amazon Fire OS `/assets/www` répertoire.
+
+2. Copie `config.xml` de `/framework/res/xml` à de votre projet `/res/xml` répertoire.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/fr/6.0.0/guide/platforms/android/config.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/6.0.0/guide/platforms/android/config.md b/www/docs/fr/6.0.0/guide/platforms/android/config.md
new file mode 100644
index 0000000..2442c45
--- /dev/null
+++ b/www/docs/fr/6.0.0/guide/platforms/android/config.md
@@ -0,0 +1,95 @@
+---
+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: Configuration d'Android
+---
+
+# Configuration d'Android
+
+Le fichier `config.xml` supervise les paramètres de base s'appliquant à l'application ainsi qu'à chaque instance de la classe CordovaWebView. Cette section décrit en détail les préférences uniquement liées à la compilation pour Android. 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, vaut par défaut `true`): Détermine si l'application doit continuer de s'exécuter en arrière-plan, même après le déclenchement d'un événement `[pause](../../../cordova/events/events.pause.html)`. 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"/>
+
+
+* `LoadUrlTimeoutValue`(numéro en millisecondes, par défaut à `20000` , à 20 secondes): lors du chargement d'une page, la quantité de temps à attendre avant de lancer une erreur de délai d'attente. Cet exemple définit un délai de 10 secondes au lieu de 20 :
+
+ <preference name="LoadUrlTimeoutValue" value="10000"/>
+
+
+* `SplashScreen`(string, la valeur par défaut `splash` ): 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="mySplash"/>
+
+
+* `SplashScreenDelay`(numéro en millisecondes, par défaut, `3000` ): affiche de l'image de l'écran splash le laps de temps.
+
+ <preference name="SplashScreenDelay" value="10000"/>
+
+
+* `InAppBrowserStorageEnabled` (boolean, vaut `true` par défaut) : contrôle si les pages ouvertes dans une fenêtre InAppBrowser accèderont ou non aux même espaces de stockage ([localStorage](../../../cordova/storage/localstorage/localstorage.html) et WebSQL) que celles ouvertes avec le navigateur par défaut.
+
+ <preference name="InAppBrowserStorageEnabled" value="true"/>
+
+
+* `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="My Title,My Message"/>
+
+
+* `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="My Title,My Message"/>
+
+
+* `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="myErrorPage.html"/>
+
+
+* `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"/>
+
+
+* `SetFullscreen`(boolean, la valeur par défaut `false` ): identique à la `Fullscreen` paramètre dans la configuration globale de ce fichier xml. Cet élément spécifiques Android est désapprouvé en faveur de la global `Fullscreen` élément et sera supprimée dans une future version.
+
+* `AndroidLaunchMode`(string, la valeur par défaut `singleTop` ): définit l'activité `android:launchMode` attribut. Cela change de ce qui arrive lorsque l'application est lancée depuis l'icône de l'application ou l'intention et est déjà en cours d'exécution. Les valeurs valides sont `standard` , `singleTop` , `singleTask` ,`singleInstance`.
+
+ <preference name="AndroidLaunchMode" value="singleTop"/>
+
+
+* `DefaultVolumeStream`(string, la valeur par défaut `default` , ajouté dans cordova-android 3.7.0): définit quel volume le volume de matériel boutons lien vers. Par défaut c'est « appeler » pour les téléphones et les « médias » pour les tablettes. Indiquez ce « médias » d'avoir des boutons de volume de votre application à tout moment modifier le volume du média. Notez que lorsque vous utilisez le plugin de médias de Cordova, les boutons de volume vont changer dynamiquement pour contrôler le volume de médias lorsque tous les objets multimédia sont actives.
+
+* `OverrideUserAgent` (chaîne, ne pas la valeur par défaut): si la valeur, la valeur remplacera l'ancienne UserAgent de webview. Il est utile d'identifier la demande d'app/navigateur lorsque vous demandez des pages éloignées. À utiliser avec prudence, ce qui peut entraîne des problème de compitiable avec des serveurs web. Pour la plupart des cas, utilisez plutôt AppendUserAgent.
+
+ <preference name="OverrideUserAgent" value="Mozilla/5.0 My Browser" />
+
+
+* `AppendUserAgent` (chaîne, ne pas la valeur par défaut): si la valeur, la valeur s'ajoute à la fin du vieux UserAgent de webview. Lors de l'utilisation avec OverrideUserAgent, cette valeur sera ignorée.
+
+ <preference name="AppendUserAgent" value="My Browser" />
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org