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 2017/05/04 15:01:54 UTC
[13/52] [abbrv] [partial] docs commit: CB-12747: added 7.x docs
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/platforms/amazonfireos/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/7.x/guide/platforms/amazonfireos/index.md b/www/docs/fr/7.x/guide/platforms/amazonfireos/index.md
new file mode 100644
index 0000000..d2b6ab6
--- /dev/null
+++ b/www/docs/fr/7.x/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/5ad93d20/www/docs/fr/7.x/guide/platforms/amazonfireos/plugin.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/7.x/guide/platforms/amazonfireos/plugin.md b/www/docs/fr/7.x/guide/platforms/amazonfireos/plugin.md
new file mode 100644
index 0000000..b61cb77
--- /dev/null
+++ b/www/docs/fr/7.x/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/5ad93d20/www/docs/fr/7.x/guide/platforms/amazonfireos/webview.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/7.x/guide/platforms/amazonfireos/webview.md b/www/docs/fr/7.x/guide/platforms/amazonfireos/webview.md
new file mode 100644
index 0000000..2cebf81
--- /dev/null
+++ b/www/docs/fr/7.x/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/5ad93d20/www/docs/fr/7.x/guide/platforms/android/config.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/7.x/guide/platforms/android/config.md b/www/docs/fr/7.x/guide/platforms/android/config.md
new file mode 100644
index 0000000..2442c45
--- /dev/null
+++ b/www/docs/fr/7.x/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" />
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/platforms/android/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/7.x/guide/platforms/android/index.md b/www/docs/fr/7.x/guide/platforms/android/index.md
new file mode 100644
index 0000000..c6e9c30
--- /dev/null
+++ b/www/docs/fr/7.x/guide/platforms/android/index.md
@@ -0,0 +1,276 @@
+---
+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 pour la plate-forme Android
+toc_title: Android
+---
+
+# Guide pour la plate-forme Android
+
+Ce guide montre comment configurer votre environnement SDK pour déployer des applications de Cordova pour les appareils Android et comment éventuellement utiliser Android-centré des outils de ligne de commande dans votre flux de travail de développement. Vous devez installer le SDK Android indépendamment si vous voulez utiliser ces outils axés sur la plate-forme de shell ou la CLI de Cordova multi-plateforme pour le développement. Pour une comparaison entre les voies de deux développement, consultez la vue d'ensemble. Pour plus d'informations sur la CLI, consultez l'Interface de ligne de commande.
+
+## Configuration requise et support
+
+Cordova pour Android nécessite le SDK Android qui peut être installé sur le système d'exploitation OS X, Linux ou Windows. Voir du SDK Android [Configuration du système requise][1].
+
+ [1]: http://developer.android.com/sdk/index.html#Requirements
+
+Cordova supporte Android 4.0.x (en commençant par le niveau de l'API Android 14) et plus élevé. En règle générale, les versions Android deviennent non étayées par Cordova comme ils plonger au-dessous de 5 % sur Google [dashboard de distribution][2]. Android versions antérieures à la version API de niveau 10 et les versions 3.x (Honeycomb, niveaux API 11-13) tombent nettement au-dessous de ce seuil de 5 %.
+
+ [2]: http://developer.android.com/about/dashboards/index.html
+
+## Installer les outils de Cordova Shell
+
+Si vous souhaitez utiliser les outils de coquille Android-centrée de Cordova conjointement avec le SDK, Télécharger Cordova de [cordova.apache.org][3]. Sinon ignorer cette section si vous envisagez d'utiliser l'outil CLI de multi-plateforme décrit dans l'Interface de ligne de commande.
+
+ [3]: http://cordova.apache.org
+
+Le téléchargement de Cordova contient des archives distincts pour chaque plate-forme. N'oubliez pas d'élargir l'archive appropriée, `android` dans ce cas, dans un répertoire vide. Les utilitaires les pertinents sont disponibles dans le niveau supérieur `bin` répertoire. (Consultez le fichier **README** si nécessaire pour des directions plus détaillées).
+
+Ces outils de coquille permettent de créer, générer et exécuter des applications Android. Pour plus d'informations sur l'interface de ligne de commande supplémentaire qui active les fonctionnalités de plugin sur toutes les plateformes, voir Plugman à l'aide à gérer les Plugins. Voir Application Plugins pour plus d'informations sur la façon de développer des plugins.
+
+## Installez le Kit de développement Java (JDK)
+
+Installer [Java Development Kit (JDK) 7][4] ou version ultérieure.
+
+ [4]: http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
+
+Lors de l'installation sous Windows, vous devez également définir la Variable d'environnement `JAVA_HOME` selon le chemin d'installation de JDK (par exemple, C:\Program Files\Java\jdk1.7.0_75).
+
+## Installer le SDK Android
+
+Installer les [outils de Android SDK autonome][5] ou [Studio Android][6]. Procceed avec `Android Studio` si vous prévoyez Cordova nouvelle pour Android plugins ou utilisant des outils natifs pour exécuter et déboguer la plateforme Android. Dans le cas contraire, `Outils du SDK Android autonome` suffisent pour créer et déployer des applications Android.
+
+ [5]: http://developer.android.com/sdk/installing/index.html?pkg=tools
+ [6]: http://developer.android.com/sdk/installing/index.html?pkg=studio
+
+Instructions d'installation détaillées sont disponibles dans le cadre des liens d'installation ci-dessus.
+
+Pour outils de ligne de commande de Cordova pour travailler, ou la CLI qui repose sur eux, vous devez inclure les répertoires de `plate-forme-outils` et `outils` du SDK dans votre `PATH`. Sur un Mac ou Linux, vous pouvez utiliser un éditeur de texte pour créer ou modifier le fichier `~/.bash_profile` , ajoutant une ligne comme ci-dessous, en fonction d'où installe le SDK :
+
+ export PATH=${PATH}:/Development/android-sdk/platform-tools:/Development/android-sdk/tools
+
+
+Cette ligne dans `~/.bash_profile` expose ces outils dans windows terminales nouvellement ouverts. Si votre fenêtre de terminal est déjà ouvert dans OSX ou d'éviter une déconnexion/connexion sur Linux, exécutez ceci pour les rendre disponibles dans la fenêtre du terminal actuelle :
+
+ $ source ~/.bash_profile
+
+
+Pour modifier l'environnement `PATH` sous Windows :
+
+1. Cliquez sur le menu **Démarrer** dans le coin en bas à gauche du bureau, faites un clic droit sur **ordinateur**, puis sélectionnez **Propriétés**.
+
+2. Sélectionnez **Paramètres système avancés** dans la colonne de gauche.
+
+3. Dans la boîte de dialogue, appuyez sur **Variables d'environnement**.
+
+4. Sélectionnez la variable **PATH** et appuyer sur **modifier**.
+
+5. Ajouter ce qui suit à le `PATH` basé sur lequel vous avez installé le SDK, par exemple :
+
+ ;C:\Development\android-sdk\platform-tools;C:\Development\android-sdk\tools
+
+
+6. Enregistrez la valeur et fermez les deux boîtes de dialogue.
+
+## Installer les paquets SDK
+
+Ouvrez le gestionnaire de SDK Android (par exemple, par l'intermédiaire de borne : `android`) et installer :
+
+1. 5.1.1 Android (API 22) platform SDK
+2. Version d'Android SDK Build-tools 19.1.0 ou supérieur
+3. Référentiel de prise en charge Android (Extras)
+
+Pour plus de détails, voir [Installation de Packages de SDK][7] .
+
+ [7]: http://developer.android.com/sdk/installing/adding-packages.html
+
+## Configurer un émulateur
+
+Android sdk ne fournit pas de n'importe quelle instance d'émulateur par défaut par défaut. Vous pouvez créer un nouveau en exécutant `android` sur la ligne de commande. La presse **Outils → gérer AVDs** (périphériques virtuels Android), puis choisissez n'importe quel élément du **Dispositif de définitions** dans la boîte de dialogue :
+
+![][8]
+
+ [8]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_device.png
+
+Appuyez sur **Créer AVD**, éventuellement modifier le nom, puis appuyez sur **OK** pour accepter les modifications :
+
+![][9]
+
+ [9]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_newAVD.png
+
+L'AVD apparaît alors dans la liste **Des périphériques virtuels Android** :
+
+![][10]
+
+ [10]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_avds.png
+
+Pour ouvrir l'émulateur comme une demande distincte, l'AVD et cliquez sur **Démarrer**. Il lance autant qu'il le ferait sur le dispositif, avec des contrôles supplémentaires disponibles pour les boutons matériels :
+
+![][11]
+
+ [11]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_emulator.png
+
+Pour une expérience plus rapide, vous pouvez utiliser l' `Accélération de la Machine virtuelle` pour améliorer la vitesse d'exécution. De nombreux processeurs modernes fournissent des extensions pour exécuter des Machines virtuelles plus efficacement. Avant d'utiliser ce type d'accélération, vous devez déterminer si CPU de votre système actuel de développement, on supporte les technologies de virtualisation suivants :
+
+* **Technologie de virtualisation Intel** (VT-x, vmx) → [Intel VT-x pris en charge la liste des processeurs][12]
+* **AMD Virtualization** (AMD-V, SVM), pris en charge uniquement pour Linux (depuis mai 2006, tous les processeurs AMD incluent AMD-V, sauf Sempron).
+
+ [12]: http://ark.intel.com/products/virtualizationtechnology
+
+Une autre façon de savoir si votre processeur supporte la technologie de VT-x, c'est en exécutant l' `Utilitaire Intel Processor Identification Utility`, pour `Windows`, vous pouvez le télécharger depuis le [Centre de téléchargement][13]de Intel, ou vous pouvez utiliser l' [utilitaire booteable][14], qui est `Indépendant de l'OS`.
+
+ [13]: https://downloadcenter.intel.com/Detail_Desc.aspx?ProductID=1881&DwnldID=7838
+ [14]: https://downloadcenter.intel.com/Detail_Desc.aspx?ProductID=1881&DwnldID=7840&lang=eng
+
+Après avoir installer et exécuter `l'Utilitaire d'Identification des processeurs Intel` sur Windows, vous obtiendrez la fenêtre suivante, afin de vérifier si votre processeur supporte les Technologies de virtualisation :
+
+![][15]
+
+ [15]: {{ site.baseurl }}/static/img/guide/platforms/android/intel_pid_util_620px.png
+
+Afin d'accélérer l'émulateur, vous devez télécharger et installer une ou plusieurs Images de système `Atom d'Intel x 86` , ainsi que l' `Intel matériel accéléré l'exécution Manager (HAXM)`.
+
+Ouvrez votre gestionnaire de SDK Android et sélectionnez l'Image du système `Atom d'Intel x 86` , pour quelle que soit la version que vous souhaitez tester. Puis allez à `options` et sélectionnez `Intel x 86 Emulator accélérateur (HAXM)`et installer ces paquets :
+
+![][16]
+
+ [16]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_man_intel_image_haxm.png
+
+Après le téléchargement, exécuter le programme d'installation d'Intel, qui est disponible dans votre Android SDK à `Options/intel/Hardware_Accelerated_Execution_Manager`. **Remarque**:`si vous avez des difficultés pour installer le package, vous pouvez trouver plus d'informations et conseils étape par étape cochez-le` [Article Intel][17].
+
+ [17]: http://software.intel.com/en-us/android/articles/speeding-up-the-android-emulator-on-intel-architecture
+
+1. Installez une ou plusieurs Images de système `x 86 d'Intel Atom` ainsi que le `Gestionnaire d'exécution accélérée matériel Intel`, disponible sous **Extras**.
+
+2. Exécutez le programme d'installation d'Intel, qui est disponible dans votre Android SDK à `Options/intel/Hardware_Accelerated_Execution_Manager`.
+
+3. Créer un nouvel AVD avec l'objectif fixé à une image d'Intel.
+
+4. Lorsque vous démarrez l'émulateur, assurez-vous il n'y a aucun message d'erreur indiquant une panne de charger les modules HAX.
+
+## Créez un nouveau projet
+
+À ce stade, pour créer un nouveau projet, vous pouvez choisir entre l'outil CLI multiplate-forme décrit dans l'Interface de ligne de commande, ou l'ensemble des outils de coquille spécifiques à Android. Partir dans un répertoire de code source, voici l'approche de la CLI :
+
+ $ cordova create hello com.example.hello HelloWorld
+ $ cd hello
+ $ cordova platform add android
+ $ cordova prepare # or "cordova build"
+
+
+Voici l'approche de shell-outil de niveau inférieur correspondant pour Unix et Windows :
+
+ $ /path/to/cordova-android/bin/create /path/to/new/hello com.example.hello HelloWorld
+ C:\path\to\cordova-android\bin\create.bat C:\path\to\new\hello com.example.hello HelloWorld
+
+
+## Générez le projet
+
+Si vous utilisez l'interface CLI dans le développement, le répertoire de niveau supérieur `www` du répertoire du projet contient les fichiers sources. Courir à chacun d'entre eux dans le répertoire du projet pour reconstruire l'application :
+
+ $ cordova build # build all platforms that were added
+ $ cordova build android # build debug for only Android
+ $ cordova build android --debug # build debug for only Android
+ $ cordova build android --release # build release for only Android
+
+
+Si vous utilisez les outils de coquille spécifiques à Android en développement, il y a une approche différente. Une fois que vous générez le projet, source de l'application par défaut est disponible dans le sous-répertoire `assets/www` . Les commandes suivantes sont disponibles dans son sous-répertoire de `cordova` .
+
+La commande `build` nettoie les fichiers projet et régénère l'app. Voici la syntaxe pour Mac et Windows. Les deux premiers exemples génèrent des informations de débogage, et le second s'appuie les apps pour diffusion immédiate :
+
+ $ /path/to/project/cordova/build --debug
+ C:\path\to\project\cordova\build.bat --debug
+
+ $ /path/to/project/cordova/build --release
+ C:\path\to\project\cordova\build.bat --release
+
+
+## Déployer l'application
+
+Vous pouvez utiliser l'utilitaire CLI de `cordova` pour déployer l'application sur l'émulateur ou le dispositif de la ligne de commande :
+
+ $ cordova emulate android #to deploy the app on a default android emulator
+ $ cordova run android --device #to deploy the app on a connected device
+
+
+Sinon, utilisez l'interface de coquille alternative :
+
+ $ /path/to/project/cordova/run --emulator
+ $ /path/to/project/cordova/run --device
+
+
+Vous pouvez utiliser **cordova run android --list** pour voir toutes les cibles disponibles et **cordova run android --target=target_name** pour exécuter l'application sur un émulateur ou un périphérique spécifique (par exemple, `cordova run android --target="Nexus4_emulator"`).
+
+Vous pouvez également utiliser **cordova run --help** pour voir construire supplémentaire et exécuter les options.
+
+Cela pousse l'app à l'écran d'accueil et il lance :
+
+![][18]
+
+ [18]: {{ site.baseurl }}/static/img/guide/platforms/android/emulator2x.png
+
+Lorsque vous `run` l'application, vous aussi `build` il. Vous pouvez ajouter supplémentaires `--debug`, `--release`et `--nobuild` drapeaux pour contrôler comment il est construit, ou même si une reconstruction est nécessaire :
+
+ $ /path/to/project/cordova/run --emulator --nobuild
+
+
+## Autres commandes
+
+Ce qui suit génère un journal détaillé de l'application en cours d'exécution :
+
+ $ /path/to/project/cordova/log
+ C:\path\to\project\cordova\log.bat
+
+
+Le texte suivant nettoie les fichiers de projet :
+
+ $ /path/to/project/cordova/clean
+ C:\path\to\project\cordova\clean.bat
+
+
+## Ouvrez un nouveau projet dans le SDK
+
+Une fois que la plateforme android est ajouté à votre projet, vous pouvez l'ouvrir depuis [Android][6]Studio :
+
+1. Lancez l'application **Android de Studio** .
+
+2. Sélectionnez **Import Project (Eclipse ADT, Gradle, etc.)**.
+
+ ![][19]
+
+3. Sélectionnez l'emplacement où la plateforme android est stockée (`votre/projet/platforms/android`).
+
+ ![][20]
+
+4. Pour la question `Gradle Sync` vous pouvez simplement répondre **Oui**.
+
+ [19]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_project.png
+ [20]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_select_location.png
+
+Vous êtes tous ensemble maintenant et pouvez générer et exécuter l'application directement à partir de `Studio Android`.
+
+![][21]
+
+ [21]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_done.png
+
+Consultez [Vue d'ensemble Studio de Android][22] et et [génération et l'exécution de Studio Android][23] pour plus de détails.
+
+ [22]: http://developer.android.com/tools/studio/index.html
+ [23]: http://developer.android.com/tools/building/building-studio.html
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/platforms/android/plugin.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/7.x/guide/platforms/android/plugin.md b/www/docs/fr/7.x/guide/platforms/android/plugin.md
new file mode 100644
index 0000000..c6a5810
--- /dev/null
+++ b/www/docs/fr/7.x/guide/platforms/android/plugin.md
@@ -0,0 +1,183 @@
+---
+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: Plugins Android
+toc_title: Android
+---
+
+# Plugins Android
+
+Cette section fournit des détails pour savoir comment implémenter le code du plugin native sur la plateforme Android. Avant de lire ceci, voir Application Plugins pour avoir un aperçu de la structure du plugin et son interface commune de JavaScript. Cette section continue de démontrer l'échantillon *écho* plugin qui communique de la webview Cordova à la plate-forme native et le dos. Pour un autre exemple, voir aussi les commentaires à [CordovaPlugin.java][1].
+
+ [1]: https://github.com/apache/cordova-android/blob/master/framework/src/org/apache/cordova/CordovaPlugin.java
+
+Plugins Android sont basés sur Android-Cordova, qui consiste en une WebView Android avec crochets attachés à elle. Plugins sont représentés comme des mappages de classe dans le `config.xml` fichier. Un plugin est composé d'au moins une classe Java qui étend la `CordovaPlugin` classe, de la substitution de l'un de ses `execute` méthodes. Aussi pratique, le plugin devrait également réaliser au mieux `[pause](../../../cordova/events/events.pause.html)` et `[resume](../../../cordova/events/events.resume.html)` des événements, ainsi que tout message transitant entre les plugins. Plugins avec longues requêtes, activité de fond telles que la lecture du média, auditeurs ou état interne doit mettre en œuvre la `onReset()` méthode aussi bien. Il exécute quand le `WebView` navigue vers une nouvelle page ou des actualisations, qui recharge le JavaScript.
+
+## Classe plugin cartographie
+
+Interface JavaScript du plugin utilise la `cordova.exec` méthode comme suit :
+
+ exec (< successFunction >, < failFunction >, < service >, < action >, [< args >]) ;
+
+
+Cela marshale une demande de la WebView vers le côté natif Android, effectivement l'appel la `action` méthode sur la `service` classe, avec des arguments supplémentaires passés dans le `args` tableau.
+
+Si vous distribuez un plugin sous Java fichier ou un fichier *jar* de ses propres, le plugin doit être spécifié dans votre application Android-Cordova `res/xml/config.xml` fichier. Voir Application Plugins pour plus d'informations sur la façon d'utiliser le `plugin.xml` fichier à injecter ce `feature` élément :
+
+ <feature name="<service_name>">
+ <param name="android-package" value="<full_name_including_namespace>" />
+ </feature>
+
+
+Le nom de service correspond à celle utilisée dans le code JavaScript `exec` appeler. La valeur est identificateur d'espace de noms complet de la classe Java. Dans le cas contraire, le plugin peut compiler mais toujours être indisponible à Cordova.
+
+## Durée de vie et initialisation du Plugin
+
+Une seule instance d'un objet plugin est créée pour la vie de chaque `WebView` . Plugins ne sont pas instanciés jusqu'à ce qu'ils sont tout d'abord référencées par un appel de JavaScript, à moins que `<param>` avec un `onload` `name` attribut a la valeur `"true"` dans `config.xml` . Par exemple :
+
+ <feature name="Echo">
+ <param name="android-package" value="<full_name_including_namespace>" />
+ <param name="onload" value="true" />
+ </feature>
+
+
+Plugins devraient utiliser la `initialize` méthode pour leur logique de démarrage.
+
+ @Override
+ public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ // your init code here
+ }
+
+
+## Écriture d'un Plugin Java Android
+
+Une demande de plugin pour le côté natif déclenche un appel JavaScript et le plugin Java correspondant est mappé correctement en le `config.xml` fichier, mais en quoi le dernier Android Plugin Java classe ressemble ? Tout ce qui est dépêché sur le plugin avec du JavaScript `exec` fonction est passée dans la classe plugin `execute` méthode. La plupart `execute` implémentations ressemblent à ceci :
+
+ @Override public boolean exécuter (cordes, args JSONArray, CallbackContext callbackContext) lève JSONException {si (« beep".equals(action)) {this.beep(args.getLong(0)) ;
+ callbackContext.success() ;
+ retourner la valeur true ;
+ } return false ; / / Retour des résultats faussement une erreur « MethodNotFound ».
+ }
+
+
+Le JavaScript `exec` de fonction `action` paramètre correspond à une méthode de classe privée d'expédier avec les paramètres facultatifs.
+
+Quand interception d'exceptions et de retourner des erreurs, il est important pour plus de clarté que des erreurs retournées aux noms d'exception du Java JavaScript match autant que possibles.
+
+## Filetage
+
+Le plugin JavaScript est *pas* exécuté dans le thread principal de le `WebView` interface ; au lieu de cela, il s'exécute le `WebCore` fil, comme le fait la `execute` méthode. Si vous avez besoin d'interagir avec l'interface utilisateur, vous devez utiliser la variation suivante :
+
+ @Override
+ public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ if ("beep".equals(action)) {
+ final long duration = args.getLong(0);
+ cordova.getActivity().runOnUiThread(new Runnable() {
+ public void run() {
+ ...
+ callbackContext.success(); // Thread-safe.
+ }
+ });
+ return true;
+ }
+ return false;
+ }
+
+
+Utiliser ce qui suit si vous n'avez pas besoin d'exécuter sur l'interface principale de thread, mais ne voulez pas bloquer la `WebCore` visser soit :
+
+ @Override
+ public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
+ if ("beep".equals(action)) {
+ final long duration = args.getLong(0);
+ cordova.getThreadPool().execute(new Runnable() {
+ public void run() {
+ ...
+ callbackContext.success(); // Thread-safe.
+ }
+ });
+ return true;
+ }
+ return false;
+ }
+
+
+## Echo Android 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="android">
+ <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.");
+ }
+ }
+ }
+
+
+Les importations nécessaires en haut du fichier étend la classe de `CordovaPlugin` , dont `execute()` méthode, elle se substitue pour recevoir les messages de `exec()` . La `execute()` méthode teste tout d'abord la valeur de `action` , qui dans ce cas il est un seul valide `echo` valeur. Tout autre retour d'action `false` et se traduit par une `INVALID_ACTION` erreur, qui se traduit par un rappel de l'erreur invoqué sur le côté de JavaScript.
+
+Ensuite, la méthode récupère la chaîne echo à l'aide du `args` de l'objet `getString` méthode, en spécifiant le premier paramètre passé à la méthode. Après que la valeur est passée à un privé `echo` méthode, il est paramètre-vérifié pour s'assurer que ce n'est pas `null` ou une chaîne vide, auquel cas `callbackContext.error()` appelle rappel d'erreur de JavaScript. Si les divers contrôles passent, la `callbackContext.success()` passe l'original `message` chaîne à rappel réussi de JavaScript comme paramètre.
+
+## Intégration Android
+
+Android propose un `Intent` système qui permet aux processus de communiquer entre eux. Plugins ont accès à un `CordovaInterface` objet, qui peut accéder à l'Android `Activity` qui exécute l'application. C'est la `Context` requise pour lancer un nouveau Android `Intent` . Le `CordovaInterface` permet aux plugins démarrer une `Activity` pour un résultat et configurer le plugin de rappel pour quand le `Intent` retourne à l'application.
+
+À partir de 2.0 de Cordova, Plugins peuvent accéder n'est plus directement le `Context` et l'héritage `ctx` membre est obsolète. Tous les `ctx` méthodes existent sur le `Context` , afin que les deux `getContext()` et `getActivity()` peut retourner l'objet requis.
+
+## Débogage des Plugins Android
+
+Eclipse permet de déboguer des plugins comme source de Java inclus dans le projet. Seulement la dernière version de l'Android Developer Tools vous permet d'attacher le code source à dépendances *JAR* , alors cette fonction n'est pas encore entièrement supportée.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/fr/7.x/guide/platforms/android/tools.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/7.x/guide/platforms/android/tools.md b/www/docs/fr/7.x/guide/platforms/android/tools.md
new file mode 100644
index 0000000..fe8a469
--- /dev/null
+++ b/www/docs/fr/7.x/guide/platforms/android/tools.md
@@ -0,0 +1,205 @@
+---
+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: Android Shell Tool Guide
+---
+
+# Android Shell Tool Guide
+
+Ce guide montre comment utiliser ensemble de Cordova d'outils axés sur la plate-forme de shell pour développer des applications Android. Cette voie de développement, discutée dans l'aperçu, vous offrent un plus grand choix de développement que l'outil CLI multiplate-forme décrit dans l'Interface de ligne de commande. Par exemple, vous devez utiliser les outils de shell lorsque vous déployez une coutume Cordova WebView aux côtés de composants natifs. Avant d'utiliser ou l'autre voie de développement, vous devez d'abord configurer l'environnement Android SDK comme décrit dans le Guide de la plate-forme Android.
+
+Pour activer les outils de la coquille pour Android, Télécharger Cordova de [cordova.apache.org][1]. Le téléchargement contient les archives distincts pour chaque plate-forme. Développez chacun vous souhaitez cibler, `android` dans ce cas. Les outils pertinents sont généralement disponibles dans le niveau supérieur `bin` répertoire, sinon, consultez le fichier **README** pour en savoir plus.
+
+ [1]: http://cordova.apache.org
+
+Ces outils vous permettent de créer, générer et exécuter des applications Android. Pour plus d'informations sur l'interface de ligne de commande supplémentaire qui active les fonctionnalités de plugin sur toutes les plateformes, voir Plugman à l'aide à gérer les Plugins. Voir Application Plugins pour plus d'informations sur la façon de développer des plugins.
+
+## Créer un projet
+
+Exécutez le `create` commande, en spécifiant le chemin d'accès existant au projet, l'identificateur de package inverse-domaine-style et nom complet de l'application. Voici la syntaxe pour Mac/Linux et Windows :
+
+ $ /path/to/cordova-android/bin/create /path/to/project com.example.project_name ProjectName
+
+ C:\>\path\to\cordova-android\bin\create.bat \path\to\project com.example.project_name ProjectName
+
+
+## Construire
+
+Cela nettoie puis génère un projet.
+
+Debug, sur Mac/Linux ou Windows :
+
+ $ /path/to/project/cordova/build --debug
+
+ C:\>\path\to\project\cordova\build.bat --debug
+
+
+Date de sortie, sous Mac/Linux ou Windows :
+
+ $ /path/to/project/cordova/build --release
+
+ C:\>\path\to\project\cordova\build.bat --release
+
+
+## Exécuter l'application
+
+Le `run` commande accepte les paramètres *optionnels* suivants :
+
+* Spécification de la cible. Cela inclut `--emulator` , `--device` , ou`--target=<targetID>`.
+
+* Construire la spécification. Cela inclut `--debug` , `--release` , ou`--nobuild`.
+
+ $ /path/to/project/cordova/run [Target] [Build]
+
+ C:\>\path\to\project\cordova\run.bat [Target] [Build]
+
+
+Assurez-vous que vous créez au moins un Android Virtual Device, autrement vous êtes invité à le faire avec la `android` commande. Si plusieurs AVD est disponible en tant que cible, vous êtes invité à sélectionner un. Par défaut la `run` commande détecte un appareil ou un émulateur en cours d'exécution si aucun périphérique n'est trouvé.
+
+## Signature de l'App
+
+Vous pouvez consulter Android app signature exigences ici : http://developer.android.com/tools/publishing/app-signing.html
+
+Pour signer une application, vous devez les paramètres suivants :
+
+* Keystore (`--keystore`): chemin d'accès à un fichier binaire qui peut contenir un jeu de clés.
+
+* Keystore password (`--storePassword`): mot de passe pour le fichier de clés
+
+* Alias (`--alias`): l'id spécifiant la clé privée utilisée pour le chant.
+
+* Mot de passe (`--password`): mot de passe de clé privée spécifié.
+
+* Type du keystore (`--keystoreType`): pkcs12, jks (par défaut : détection automatique basée sur l'extension de fichier)
+
+Ces paramètres peuvent être spécifiés en utilisant les arguments de ligne de commande ci-dessus à `construire` ou `exécuter` des scripts.
+
+Alternativement, vous pouvez spécifier les dans un fichier (build.json) de configuration de build à l'aide ( `--buildConfig` ) argument. Voici un exemple de fichier de configuration de génération :
+
+ {
+ "android": {
+ "debug": {
+ "keystore": "..\android.keystore",
+ "storePassword": "android",
+ "alias": "mykey1",
+ "password" : "password",
+ "keystoreType": ""
+ },
+ "release": {
+ "keystore": "..\android.keystore",
+ "storePassword": "",
+ "alias": "mykey2",
+ "password" : "password",
+ "keystoreType": ""
+ }
+ }
+ }
+
+
+Pour la version signature, mots de passe ne peuvent être exclus et le système de génération attribuera une invite vous demandant le mot de passe.
+
+Il y a aussi des soutien à mélanger et assortir les arguments de ligne de commande et les paramètres dans le fichier build.json. Valeurs de l'argument de ligne de comamnd obtiendrez priorité. Cela peut être utile pour spécifier des mots de passe sur la ligne de commande.
+
+## Exploitation forestière
+
+ $ /path/to/project/cordova/log
+
+ C:\>\path\to\project\cordova\log.bat
+
+
+## Nettoyage
+
+ $ /path/to/project/cordova/clean
+
+ C:\>\path\to\project\cordova\clean.bat
+
+
+## Bâtiment avec Gradle
+
+À partir de cordova-android@4.0.0, la génération de projet à l'aide de [Gradle][2]. Pour obtenir des instructions sur le bâtiment avec ANT, se référer aux anciennes versions de la documentation.
+
+ [2]: http://www.gradle.org/
+
+### Propriétés Gradle
+
+Ces [Propriétés][3] peuvent être définies pour personnaliser la génération :
+
+ [3]: http://www.gradle.org/docs/current/userguide/tutorial_this_and_that.html
+
+* **cdvBuildMultipleApks** (par défaut : false)
+
+ Si celui-ci est défini, les fichiers APK multiples seront générés : une par natif plate-forme prise en charge de projets de bibliothèques (x 86, ARM, etc.). Cela peut être important si votre projet utilise des grandes bibliothèques natives, qui peuvent augmenter considérablement la taille de l'APK généré.
+
+ Si ce n'est pas défini, alors un APK unique qui peut être utilisé sur tous les appareils est généré.
+
+* **cdvVersionCode**
+
+ Substitue le versionCode situé dans `AndroidManifest.xml`
+
+* **cdvReleaseSigningPropertiesFile** (par défaut : release-signing.properties)
+
+ Chemin vers un fichier .properties qui contient les informations de signature pour diffusion immédiate s'appuie. Le fichier devrait ressembler à :
+
+ storeFile=relative/path/to/keystore.p12
+ storePassword=SECRET1
+ storeType=pkcs12
+ keyAlias=DebugSigningKey
+ keyPassword=SECRET2
+
+
+ `storePassword` et `keyPassword` sont facultatifs et vont demandera si omise.
+
+* **cdvDebugSigningPropertiesFile** (par défaut : debug-signing.properties)
+
+ Même cdvReleaseSigningPropertiesFile, mais pour le débogage s'appuie. Utile lorsque vous avez besoin de partager une clé de signature avec d'autres développeurs.
+
+* **cdvMinSdkVersion**
+
+ Remplace la valeur de `minSdkVersion` dans `AndroidManifest.xml`. Utile lorsque vous créez plusieurs APKs s'inspire de la version SDK.
+
+* **cdvBuildToolsVersion**
+
+ Substituer la valeur automatiquement détecté `android.buildToolsVersion` .
+
+* **cdvCompileSdkVersion**
+
+ Substituer la valeur automatiquement détecté `android.compileSdkVersion` .
+
+### Extension build.gradle
+
+Si vous devez personnaliser `build.gradle`, plutôt que de modifier directement, vous devez créer un fichier de frère nommé `build-extras.gradle`. Ce fichier sera inclus par le principal `build.gradle` lorsqu'il est présent. Voici un exemple :
+
+ # Example build-extras.gradle
+ # This file is included at the beginning of `build.gradle`
+ ext.cdvDebugSigningPropertiesFile = '../../android-debug-keys.properties'
+ # When set, this function allows code to run at the end of `build.gradle`
+ ext.postBuildExtras = {
+ android.buildTypes.debug.applicationIdSuffix = '.debug'
+ }
+
+
+Remarquez que les plugins peut inclure également `build-extras.gradle` fichiers via :
+
+ <framework src="some.gradle" custom="true" type="gradleReference" />
+
+
+### Exemple de Build
+
+ export ORG_GRADLE_PROJECT_cdvMinSdkVersion=14
+ cordova build android -- --gradleArg=-PcdvBuildMultipleApks=true
\ No newline at end of file
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org