cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From agri...@apache.org
Subject [09/51] [partial] Add non-en docs for 3.5.0
Date Mon, 26 May 2014 14:21:28 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/187a4fe9/docs/fr/3.5.0/guide/platforms/amazonfireos/index.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/amazonfireos/index.md b/docs/fr/3.5.0/guide/platforms/amazonfireos/index.md
new file mode 100644
index 0000000..53d3821
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/amazonfireos/index.md
@@ -0,0 +1,127 @@
+---
+
+licence : une licence à l'Apache Software Foundation (ASF) au titre d'un ou plusieurs contrats de licence pour le cotisant. Voir le fichier avis distribué avec ce travail d'information additionnelle concernant les droits d'auteur. L'ASF licenses ce fichier vous sous Apache License, Version 2.0 (la "licence") ; vous ne pouvez utiliser ce fichier sauf en conformité avec la licence. Vous pouvez obtenir une copie de la licence à
+
+           http://www.Apache.org/licenses/License-2.0 sauf si requis par la loi applicable ou accord écrit, distribué sous la licence de logiciel est distribué sur un « Tel quel » fondement, sans garanties ou CONDITIONS d'aucune sorte, explicite ou implicite.  Voir la licence pour la langue spécifique régissant les autorisations et les limites
+    
+
+## aux termes de la licence.
+
+# 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
+*   Amazon Fire OS WebViews
+*   Amazon Fire OS Plugins
+
+## Exigences et soutien
+
+Développement d'applications de Cordova pour Amazon Fire OS requiert le SDK Android et le SDK de WebView d'Amazon. Vérifier les conditions requises pour ces kits de développement logiciel en utilisant les liens ci-dessous :
+
+*   [Système Android SDK][1]
+
+*   [Amazon WebView SDK][2]
+
+ [1]: http://developer.android.com/sdk/
+ [2]: https://developer.amazon.com/sdk/fire/IntegratingAWV.html#installawv
+
+## Installation
+
+### Android SDK
+
+Installer le SDK Android de [developer.android.com/sdk][1]. 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.
+
+Pour les outils de ligne de commande de Cordova pour travailler, vous devez inclure le SDK `tools` et `platform-tools` des répertoires dans votre environnement de chemin d'accès.
+
+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ù le kit de développement logiciel installe :
+
+    export PATH = ${chemin}: / / adt-bundle/sdk/plateforme-outils de développement: / développement/adt-bundle/sdk/tools
+    
+
+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
+    
+
+Pour modifier l'environnement PATH sur Windows 7 :
+
+*   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, par exemple, ajoutez ce qui suit :
+    
+        ;C:\Development\adt-bundle\sdk\platform-Tools ;C:\Development\adt-bundle\sdk\tools
+        
+
+*   Enregistrez la valeur et fermez les deux boîtes de dialogue.
+
+Vous devrez peut-être également activer Java et Open ant une invite de commandes et tapez `java` , puis tapez également `ant` . Ajoutez le chemin d'accès si elle ne pas s'exécuter :
+
+    ;%JAVA_HOME%\bin;%ANT_HOME%\bin
+    
+
+### Amazon WebView SDK
+
+Télécharger le SDK de WebView Amazon depuis [Amazon Developer Portal][2].
+
+*   Créer un `libs/` dossier `~/.cordova/lib/amazon-fireos/cordova/3.1.0/` dossier.
+*   Ajouter le `awv_interface.jar` depuis le SDK téléchargé à`~/.cordova/lib/amazon-fireos/cordova/3.1.0/libs/`
+
+## Ouvrez un projet dans le SDK
+
+Utilisation du `cordova` utilitaire de mettre en place un nouveau projet, tel que décrit dans The 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
+    
+
+Une fois créé, vous pouvez utiliser l'éclipse qui est livré avec le SDK Android pour le modifier :
+
+*   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**: ![][3]
+
+*   Accédez à `hello` , ou n'importe quel répertoire vous avez créé pour le projet, puis à la `platforms/amazon-fireos` sous-répertoire.
+
+*   Appuyez sur **Terminer**.
+
+ [3]: img/guide/platforms//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 le projet construire cible, sélectionnez le plus haut niveau de l'API Android que vous avez installé.
+
+*   Cliquez sur **OK**.
+
+*   Sélectionnez **nettoyer** dans le menu **projet** . Cela devrait corriger toutes les erreurs dans le projet.
+
+## 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][4]et utiliser un câble mini USB à brancher sur votre système.
+
+ [4]: http://developer.android.com/tools/device.html
+
+Vous pouvez pousser l'app à l'appareil de la ligne de commande :
+
+    $ cordova run amazon-fireos
+    
+
+En alternance au sein d'Eclipse, cliquez droit sur le projet et choisissez **exécute en tant que → Application Android**.
+
+**Note**: actuellement, test via un émulateur n'est pas pris en charge pour Amazon WebView basé apps.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/187a4fe9/docs/fr/3.5.0/guide/platforms/amazonfireos/plugin.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/amazonfireos/plugin.md b/docs/fr/3.5.0/guide/platforms/amazonfireos/plugin.md
new file mode 100644
index 0000000..7c2dbc8
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/amazonfireos/plugin.md
@@ -0,0 +1,100 @@
+---
+
+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.
+---
+
+# Amazon Fire OS Plugins
+
+Suivez les instructions fournies dans le Guide de Plugins Android 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/187a4fe9/docs/fr/3.5.0/guide/platforms/amazonfireos/webview.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/amazonfireos/webview.md b/docs/fr/3.5.0/guide/platforms/amazonfireos/webview.md
new file mode 100644
index 0000000..1d8eb38
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/amazonfireos/webview.md
@@ -0,0 +1,116 @@
+---
+
+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.
+---
+
+# Amazon Fire OS WebViews
+
+3.0.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.
+
+## Conditions préalables
+
+*   Cordova 3.0.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.  Télécharger et étendre l' [Amazone WebView SDK][1] , puis copiez le awv_interface.jar en `/framework/libs` répertoire. Créer un libs / dossier s'il n'existe pas.
+
+2.  `cd`en `/framework` et exécutez `ant jar` pour construire le bocal de cordova. Il crée le fichier .jar formé comme `cordova-x.x.x.jar` dans le `/framework` répertoire.
+
+3.  Modifier votre application `main.xml` fichier (sous `/res/layout` ) pour ressembler à ce qui suit, avec le `layout_height` , `layout_width` et `id` modifié pour l'adapter à votre application :
+    
+        <org.apache.cordova.CordovaWebView
+            android:id="@+id/tutorialView"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+        
+
+4.  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]: 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/187a4fe9/docs/fr/3.5.0/guide/platforms/android/config.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/android/config.md b/docs/fr/3.5.0/guide/platforms/android/config.md
new file mode 100644
index 0000000..177912b
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/android/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.
+---
+
+# 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 pour plus d'informations concernant les options de configuration globales.
+
+*   `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`. Affectation de `false` ne tue pas l'appli après un `pause` é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 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.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/187a4fe9/docs/fr/3.5.0/guide/platforms/android/index.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/android/index.md b/docs/fr/3.5.0/guide/platforms/android/index.md
new file mode 100644
index 0000000..d19cd85
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/android/index.md
@@ -0,0 +1,226 @@
+---
+
+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.
+---
+
+# Guide pour la plate-forme Android
+
+Ce guide montre comment configurer votre environnement de développement SDK pour déployer des applications de Cordova pour les appareils Android. Il montre comment installer le SDK Android, ouvrez un projet Android dans le SDK et déployer sur un émulateur ou un périphérique. Vous devez suivre les instructions pour installer le SDK Android, que vous utilisiez le flux de travail multi-plateforme discutée dans la vue d'ensemble, ou les outils axés sur la plate-forme de shell à Android Command-line Tools.
+
+Voir ci-dessous pour plus d'informations spécifiques à la plateforme :
+
+*   Configuration d'Android
+*   WebViews Android
+*   Plugins Android
+*   Mettre à jour Android
+*   Outils en ligne de commande Android
+
+Les outils de ligne de commande ci-dessus se référer aux versions antérieures à la 3.0 de Cordova. Voir l'Interface de ligne de commande pour plus d'informations sur l'interface actuelle.
+
+## Configuration requise et support
+
+Consultez la [Configuration requise][1] pour le SDK Android.
+
+ [1]: http://developer.android.com/sdk/index.html
+
+Cordova supporte Android 2.2, 2.3 et 4.x. En règle générale, les plates-formes sont déconseillés car ils plonger au-dessous de 5 % sur Google [dashboard de distribution][2].
+
+ [2]: http://developer.android.com/about/dashboards/index.html
+
+<!--
+NOTE, doc said:
+- Android 2.1 (Deprecated May 2013)
+- Android 3.x (Deprecated May 2013)
+-->
+
+Les développeurs doivent utiliser les `cordova` utilitaire conjointement avec le SDK Android. Voir l'Interface de ligne de commande pour plus d'informations comment faire pour l'installer, d'ajouter des projets, puis de créer et de déployer un projet.
+
+Installer le SDK Android de [developer.android.com/sdk][3]. Le sdk android est distribué sous forme de fichier 'adt - bundle - < os > - < arch > - < ver >'. Sous windows, l'adt-bundle est livré avec un installeur. Sur OSX et Linux, simplement décompresser le « adt-bundle » à l'emplacement vous stockez les outils de développement. [Plus d'informations sur l'installation du SDK Android peuvent être trouvées ici][4]
+
+ [3]: http://developer.android.com/sdk/
+ [4]: http://developer.android.com/sdk/installing/bundle.html
+
+Pour les outils de ligne de commande de Cordova pour travailler, vous devez inclure le SDK `tools` et `platform-tools` des répertoires dans votre environnement de chemin d'accès. Vous devez également `java` et `ant` . Vous avez déjà `java` et `ant` dans votre environnement de chemin, essayez leur appel à partir d'une invite de ligne de commande pour voir si ils sont absents et n'ajoute que ce qui manque à votre chemin. Sachez que les Mavericks omet `ant` par rapport aux versions précédentes de Mac OS x, alors vous devrez peut-être installer `ant` séparément si vous utilisez Mavericks ou version ultérieure de Mac OS x. Sur OSX ou Linux, vous pouvez utiliser un éditeur de texte pour créer ou modifier le `~/.bash_profile` fichier, en ajoutant une ligne comme celle-ci (modifiez les emplacements où le SDK est installé sur votre poste de travail) :
+
+    export PATH = ${chemin}: / / adt-bundle/sdk/plateforme-outils de développement: / développement/adt-bundle/sdk/tools
+    
+
+Ajouter les chemins d'accès pour `java` et `ant` si nécessaire. 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 :
+
+*   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, par exemple, ajoutez ce qui suit :
+    
+        ;C:\Development\adt-bundle\sdk\platform-Tools ;C:\Development\adt-bundle\sdk\tools
+        
+
+*   Enregistrez la valeur et fermez les deux boîtes de dialogue.
+
+*   Vous devrez peut-être également ajouter Java et ant. ouvrent une invite de commandes et tapez `java` , puis tapez également `ant` . Pour celui qui ne parviennent pas à courir, ajoute au chemin comme ceci :
+    
+        ;%JAVA_HOME%\bin;%ANT_HOME%\bin
+        
+
+## Ouvrez un projet dans le SDK
+
+Utilisation du `cordova` utilitaire de mettre en place un nouveau projet, tel que décrit dans The 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 android
+        $ cordova build
+    
+
+Une fois créé, vous pouvez utiliser l'éclipse qui est livré avec le SDK Android pour le modifier :
+
+*   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**: ![][5]
+
+*   Accédez à `hello` , ou n'importe quel répertoire vous avez créé pour le projet, puis à la `platforms/android` sous-répertoire.
+
+*   Assurez-vous que les deux `hello` et `hello-CordovaLib` sont sélectionnés à importer. Le `hello-CordovaLib` projet est nécessaire à partir de Cordova 3.3.0 parce que Cordova est maintenant utilisé comme une bibliothèque Android au lieu d'un fichier .jar.
+
+*   Appuyez sur **Terminer**.
+
+ [5]: 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 le projet construire cible, sélectionnez le plus haut niveau de l'API Android que vous avez installé.
+
+*   Cliquez sur **OK**.
+
+*   Sélectionnez **nettoyer** dans le menu **projet** . Cela devrait corriger toutes les erreurs dans le projet.
+
+## Déployer sur émulateur
+
+Vous pouvez utiliser le `cordova` utilitaire de mise à exécution d'une application dans l'émulateur, ou vous pouvez l'exécuter dans le SDK. Quoi qu'il en soit, le SDK doit tout d'abord être configuré pour afficher au moins un appareil. Pour ce faire, utilisez l'Android SDK Manager, une application de Java qui s'exécute séparément d'Eclipse. Il y a deux façons pour l'ouvrir :
+
+*   Exécutez `android` sur la ligne de commande.
+
+*   Partir au sein d'Eclipse, appuyez sur cette icône de la barre d'outils :
+    
+    ![][6]
+
+ [6]: img/guide/platforms/android/eclipse_android_sdk_button.png
+
+Une fois ouvert, le Android SDK Manager affiche diverses bibliothèques d'exécution :
+
+![][7]
+
+ [7]: img/guide/platforms/android/asdk_window.png
+
+Choisissez **Outils → gérer AVDs** (périphériques virtuels Android), puis cliquez sur n'importe quel élément de **Définitions de périphérique** dans la boîte de dialogue :
+
+![][8]
+
+ [8]: 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]: img/guide/platforms/android/asdk_newAVD.png
+
+L'AVD apparaît alors dans la liste **Des périphériques virtuels Android** :
+
+![][10]
+
+ [10]: 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]: img/guide/platforms/android/asdk_emulator.png
+
+À ce stade, vous pouvez utiliser le `cordova` utilitaire pour déployer l'application sur l'émulateur de la ligne de commande :
+
+        $ cordova émuler android
+    
+
+Si au lieu de cela, vous travaillez au sein d'Eclipse, cliquez droit sur le projet et choisissez **Exécuter en tant que → Application Android**. Vous devrez peut-être spécifier un AVD si aucun n'est encore ouvert.
+
+Pour une expérience plus rapide, vous pouvez utiliser le `Virtual Machine Acceleration` 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 pour savoir si votre processeur supporte la technologie de VT-x, c'est par l'exécution de la `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`OS Independent`.
+
+ [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 le `Intel Processor Identification Utility` sur Windows, vous obtiendrez la fenêtre suivante, afin de vérifier si votre processeur supporte les Technologies de virtualisation :
+
+![][15]
+
+ [15]: img/guide/platforms/android/intel_pid_util_620px.png
+
+Afin d'accélérer l'émulateur, vous devez télécharger et installer un ou plusieurs `Intel x86 Atom` des Images de système, ainsi que la`Intel Hardware Accelerated Execution Manager (HAXM)`.
+
+Ouvrez votre gestionnaire de SDK Android et sélectionnez le `Intel x86 Atom` Image du système, quelle que soit la version que vous souhaitez tester. Ensuite, allez à `Extras` et sélectionnez `Intel x86 Emulator Accelerator (HAXM)` et d'installer ces paquets :
+
+![][16]
+
+ [16]: 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 au sein de votre Android SDK à `extras/intel/Hardware_Accelerated_Execution_Manager` . **Remarque**: `If you have any problems installing the package, you can find more information and step by step guidance check this` [Article Intel][17] .
+
+ [17]: http://software.intel.com/en-us/android/articles/speeding-up-the-android-emulator-on-intel-architecture
+
+Une fois installé, afin de tester, créer de nouveau un AVD avec le `CPU/ABI` défini sur une `Intel (Atom) x86` Image :
+
+![][18]
+
+ [18]: img/guide/platforms/android/asdk_new_and_dev_intel.png
+
+Si vous utilisez `Linux-based system` , suivez les instructions dans le [Site des développeurs Android][19].
+
+ [19]: http://developer.android.com/tools/devices/emulator.html#vm-linux
+
+Lorsque vous démarrez l'émulateur, assurez-vous il n'y a aucun message d'erreur indiquant une panne de charger les modules HAXM.
+
+## 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][20]et utiliser un câble mini USB à brancher sur votre système.
+
+ [20]: http://developer.android.com/tools/device.html
+
+Vous pouvez pousser l'app à l'appareil de la ligne de commande :
+
+        $ cordova run android
+    
+
+En alternance au sein d'Eclipse, cliquez droit sur le projet et choisissez **Exécuter en tant que → Application Android**.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/187a4fe9/docs/fr/3.5.0/guide/platforms/android/plugin.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/android/plugin.md b/docs/fr/3.5.0/guide/platforms/android/plugin.md
new file mode 100644
index 0000000..af46d1f
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/android/plugin.md
@@ -0,0 +1,176 @@
+---
+
+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.
+---
+
+# 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` et `resume` 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/187a4fe9/docs/fr/3.5.0/guide/platforms/android/tools.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/android/tools.md b/docs/fr/3.5.0/guide/platforms/android/tools.md
new file mode 100644
index 0000000..7727dcc
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/android/tools.md
@@ -0,0 +1,68 @@
+---
+
+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.
+---
+
+# Outils de ligne de commande Android
+
+Le `cordova` de l'utilitaire est un outil de haut niveau qui vous permet de créer des applications sur plusieurs plateformes à la fois. Une ancienne version du framework Cordova fournit des ensembles d'outils de ligne de commande spécifiques à chaque plate-forme. Pour les utiliser comme une alternative à la CLI, vous devez télécharger cette version de Cordova de [cordova.apache.org][1]. Le téléchargement contient les archives distincts pour chaque plate-forme. Développez la plate-forme que vous voulez cibler. Les outils décrits ici 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
+
+Pour plus d'informations sur l'interface de bas niveau qui permet aux plugins, voir Plugman à l'aide à gérer les Plugins. Pour une vue d'ensemble, consultez Application 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 et Windows :
+
+    $ /path/to/cordova-android/bin/create /path/to/project com.example.project_name ProjectName
+    $ C:\path\to\cordova-android\bin\create.bat C:\path\to\project com.example.project_name ProjectName
+    
+
+## Construire
+
+Cela nettoie puis génère un projet.
+
+Debug, sur Mac ou Windows :
+
+    $ /path/to/project/cordova/build --debug
+    $ C:\path\to\project\cordova\build.bat --debug
+    
+
+Date de sortie, sur Mac 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 \[cible\] \[construire\] $ C:\path\to\project\cordova\run.bat \[cible\] \[construire\]
+
+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é.
+
+## 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
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/187a4fe9/docs/fr/3.5.0/guide/platforms/android/upgrading.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/android/upgrading.md b/docs/fr/3.5.0/guide/platforms/android/upgrading.md
new file mode 100644
index 0000000..b4a05a8
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/android/upgrading.md
@@ -0,0 +1,432 @@
+---
+
+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.
+---
+
+# Mise à jour Android
+
+Ce guide montre comment modifier des projets Android mise à niveau d'anciennes versions de Cordova. La plupart de ces instructions s'appliquent aux projets créés avec un ensemble plu d'outils de ligne de commande qui précèdent le `cordova` utilitaire CLI. Voir l'Interface de ligne de commande pour plus d'informations comment mettre à jour la version de l'interface CLI.
+
+## Mise à niveau vers 3.3.0 de 3.2.0
+
+Suivez les mêmes instructions que pour`3.2.0`.
+
+À partir de 3.3.0, le runtime de Cordova est maintenant compilé comme une bibliothèque Android au lieu d'un pot. Ceci ne devrait avoir aucun effet pour l'utilisation de ligne de commande, mais IDE utilisateurs auront besoin d'importer le nouvellement ajouté `MyProject-CordovaLib` projet dans leur espace de travail.
+
+## Mise à niveau vers 3.2.0 de 3.1.0
+
+Pour les projets qui ont été créés avec le cordova CLI :
+
+1.  Mise à jour le `cordova` version CLI. Voir l'Interface de ligne de commande.
+
+2.  Exécutez`cordova platform update android`
+
+Pour les projets ne créés pas avec la CLI de cordova, exécutez :
+
+        bin/update <project_path>
+    
+
+**Avertissement :** Commençant sur Android 4.4, création d'un élément du fichier d'entrée avec type = « file » n'ouvrira pas la boîte de dialogue Sélecteur. Il s'agit d'une régression avec Chrome sur Android et le problème peut être reproduit dans le navigateur de Chrome autonome sur Android (voir http://code.google.com/p/android/issues/detail?id=62220) la solution de contournement suggérée est d'utiliser le transfert de fichiers et fichiers plugins pour Android 4.4. Vous pouvez écouter un événement onClick du input type = « file » et ensuite apparaître un sélecteur de fichier UI. Afin de relier les données du formulaire avec le téléchargement, vous pouvez utiliser JavaScript pour fixer des valeurs de formulaire à la requête POST plusieurs partie qui fait du transfert de fichiers. Ce bug existe toujours à partir de Android 4.4.2
+
+## Mise à niveau vers 3.1.0 de 3.0.0
+
+Pour les projets qui ont été créés avec le cordova CLI :
+
+1.  Mise à jour le `cordova` version CLI. Voir l'Interface de ligne de commande.
+
+2.  Exécutez`cordova platform update android`
+
+Pour les projets ne créés pas avec la CLI de cordova, exécutez :
+
+        bin/update <project_path>
+    
+
+## Mise à niveau à la CLI (3.0.0) de 2.9.0
+
+1.  Créez un projet Apache Cordova 3.0.0 utilisant le cordova CLI, tel que décrit dans l'Interface de ligne de commande.
+
+2.  Ajoutez vos plates-formes le projet cordova, par exemple :`cordova
+platform add android`.
+
+3.  Copiez le contenu de votre projet `www` Répertoire de la `www` répertoire à la racine du projet Cordoue vous venez de créer.
+
+4.  Copiez tout actif natif de votre ancien projet dans les répertoires appropriés sous `platforms/android` : ce répertoire est où votre projet cordova-android natif existe.
+
+5.  Utilisez l'outil CLI de cordova pour installer des plugins dont vous avez besoin. Notez que la CLI gère toutes les principales API comme plugins, donc ils peuvent avoir besoin d'être ajouté. Seulement 3.0.0 plugins sont compatibles avec l'interface CLI.
+
+## Mise à niveau vers 3.0.0 de 2.9.0
+
+1.  Créez un nouveau projet Apache Cordova Android.
+
+2.  Copiez le contenu de votre `www` répertoire vers le nouveau projet.
+
+3.  Copier n'importe quel actif Android natif de votre `res` répertoire vers le nouveau projet.
+
+4.  Copie sur les plug-ins que vous avez installé de la `src` sous-répertoires dans le nouveau projet.
+
+5.  Assurez-vous de mettre à niveau tout obsolète `<plugin>` les références de votre ancien `config.xml` fichier pour le nouveau `<feature>` spécification.
+
+6.  Mise à jour toutes les références à la `org.apache.cordova.api` paquet d'être`org.apache.cordova`.
+    
+    **NOTE**: toutes les principales API ont été supprimées et doit être installé comme plugins. S'il vous plaît voir les Plugman à l'aide à gérer les Plugins Guide pour plus de détails.
+
+## Mise à niveau vers 2.9.0 de 2.8.0
+
+1.  Exécutez`bin/update <project_path>`.
+
+## Mise à niveau vers 2.8.0 de 2.7.0
+
+1.  Supprimer `cordova-2.7.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.8.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+<!-- SS Eclipse -->
+
+1.  Copiez le nouveau `cordova.js` dans votre projet.
+
+2.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova.js` fichier.
+
+3.  Copie le `res/xml/config.xml` fichier corresponde à`framework/res/xml/config.xml`.
+
+4.  Mise à jour `framework/res/xml/config.xml` pour avoir des paramètres similaires comme il l'a fait précédemment.
+
+5.  Copier les fichiers `bin/templates/cordova` pour le projet `cordova` répertoire.
+
+## Mise à niveau vers 2.7.0 de 2.6.0
+
+1.  Supprimer `cordova-2.6.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.7.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-2.7.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-2.7.0.js` fichier.
+
+6.  Copie le `res/xml/config.xml` faire correspondre`framework/res/xml/config.xml`.
+
+7.  Mise à jour `framework/res/xml/config.xml` pour avoir des paramètres similaires comme il l'a fait précédemment.
+
+8.  Copier les fichiers `bin/templates/cordova` pour le projet `cordova` répertoire.
+
+## Mise à niveau à 2.6.0 de 2.5.0
+
+1.  Supprimer `cordova-2.5.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.6.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-2.6.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-2.6.0.js` fichier.
+
+6.  Copie le `res/xml/config.xml` faire correspondre`framework/res/xml/config.xml`.
+
+7.  Mise à jour `framework/res/xml/config.xml` pour avoir des paramètres similaires comme il l'a fait précédemment.
+
+8.  Copier les fichiers `bin/templates/cordova` pour le projet `cordova` répertoire.
+
+Exécuter `bin/update <project>` avec le chemin d'accès du projet figurant dans le répertoire Source de Cordova.
+
+## Mise à niveau vers la version 2.5.0 de 2.4.0
+
+1.  Supprimer `cordova-2.4.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.5.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-2.5.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-2.5.0.js` fichier.
+
+6.  Copie le `res/xml/config.xml` faire correspondre`framework/res/xml/config.xml`.
+
+7.  Mise à jour `framework/res/xml/config.xml` pour avoir des paramètres similaires comme il l'a fait précédemment.
+
+8.  Copier les fichiers `bin/templates/cordova` pour le projet `cordova` répertoire.
+
+## Mise à niveau vers 2.4.0 de 2.3.0
+
+1.  Supprimer `cordova-2.3.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.4.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-2.4.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-2.4.0.js` fichier.
+
+6.  Copie le `res/xml/config.xml` faire correspondre`framework/res/xml/config.xml`.
+
+7.  Copier les fichiers `bin/templates/cordova` pour le projet `cordova` répertoire.
+
+## Mise à niveau vers 2.3.0 de 2.2.0
+
+1.  Supprimer `cordova-2.2.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.3.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-2.3.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-2.3.0.js` fichier.
+
+6.  Copie le `res/xml/config.xml` faire correspondre`framework/res/xml/config.xml`.
+
+7.  Copier les fichiers `bin/templates/cordova` pour le projet `cordova` répertoire.
+
+## Mise à niveau vers 2.2.0 de 2.1.0
+
+1.  Supprimer `cordova-2.1.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.2.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-2.2.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-2.2.0.js` fichier.
+
+6.  Copie le `res/xml/config.xml` faire correspondre`framework/res/xml/config.xml`.
+
+7.  Copier les fichiers `bin/templates/cordova` pour le projet `cordova` répertoire.
+
+## Mise à niveau vers 2.1.0 de 2.0.0
+
+1.  Supprimer `cordova-2.0.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.1.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-2.1.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-2.1.0.js` fichier.
+
+6.  Copie le `res/xml/config.xml` faire correspondre`framework/res/xml/config.xml`.
+
+7.  Copier les fichiers `bin/templates/cordova` pour le projet `cordova` répertoire.
+
+## Mise à niveau vers 2.0.0 de 1.9.0
+
+1.  Supprimer `cordova-1.9.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-2.0.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-2.0.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-2.0.0.js` fichier.
+
+6.  Copie le `res/xml/config.xml` faire correspondre`framework/res/xml/config.xml`.
+
+Dans la 2.0.0 version, le `config.xml` fichier combine et remplace `cordova.xml` et `plugins.xml` . Les anciens fichiers sont obsolètes et pendant qu'ils travaillent toujours en 2.0.0, cessera de fonctionner dans une version ultérieure.
+
+## Mise à niveau vers 1.9.0 de 1.8.1
+
+1.  Supprimer `cordova-1.8.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-1.9.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-1.9.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-1.9.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+En raison de l'introduction de la `CordovaWebView` dans le 1.9.0 libération, plugins tiers peuvent ne pas fonctionner. Ces plugins ont besoin d'obtenir un contexte de le `CordovaInterface` à l'aide de `getContext()` ou `getActivity()` . Si vous n'êtes pas un développeur Android expérimenté, veuillez contacter le responsable de plugin et ajouter cette tâche à leur traqueur de bug.
+
+## Mise à niveau vers 1.8.0 de 1.8.0
+
+1.  Supprimer `cordova-1.8.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-1.8.1.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-1.8.1.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-1.8.1.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+## Mise à niveau vers 1.8.0 de 1.7.0
+
+1.  Supprimer `cordova-1.7.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-1.8.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-1.8.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-1.8.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+## Mise à niveau vers 1.8.0 de 1.7.0
+
+1.  Supprimer `cordova-1.7.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-1.8.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-1.8.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-1.8.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+## Mise à niveau vers 1.7.0 de 1.6.1
+
+1.  Supprimer `cordova-1.6.1.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-1.7.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-1.7.0.js` dans votre projet.
+
+5.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+## Mise à niveau vers 1.6.1 de 1.6.0
+
+1.  Supprimer `cordova-1.6.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-1.6.1.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-1.6.1.js` dans votre projet.
+
+5.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+## Mise à niveau vers 1.6.0 de 1.5.0
+
+1.  Supprimer `cordova-1.5.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-1.6.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-1.6.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-1.6.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+7.  Remplacer `res/xml/phonegap.xml` avec `res/xml/cordova.xml` pour correspondre`framework/res/xml/cordova.xml`.
+
+## Mise à niveau vers 1.5.0 de 1.4.0
+
+1.  Supprimer `phonegap-1.4.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `cordova-1.5.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `cordova-1.5.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `cordova-1.5.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+7.  Remplacer `res/xml/phonegap.xml` avec `res/xml/cordova.xml` pour correspondre`framework/res/xml/cordova.xml`.
+
+## Mise à niveau vers 1.4.0 de 1.3.0
+
+1.  Supprimer `phonegap-1.3.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `phonegap-1.4.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `phonegap-1.4.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `phonegap-1.4.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+7.  Mise à jour `res/xml/phonegap.xml` pour correspondre`framework/res/xml/phonegap.xml`.
+
+## Mise à niveau vers 1.3.0 de 1.2.0
+
+1.  Supprimer `phonegap-1.2.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `phonegap-1.3.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `phonegap-1.3.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `phonegap-1.2.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+7.  Mise à jour `res/xml/phonegap.xml` pour correspondre`framework/res/xml/phonegap.xml`.
+
+## Mise à niveau vers 1.2.0 de 1.1.0
+
+1.  Supprimer `phonegap-1.1.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `phonegap-1.2.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `phonegap-1.2.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `phonegap-1.2.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+7.  Mise à jour `res/xml/phonegap.xml` pour correspondre`framework/res/xml/phonegap.xml`.
+
+## Mise à niveau vers 1.1.0 de 1.0.0
+
+1.  Supprimer `phonegap-1.0.0.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `phonegap-1.1.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `phonegap-1.1.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `phonegap-1.1.0.js` fichier.
+
+6.  Mise à jour `res/xml/plugins.xml` pour correspondre`framework/res/xml/plugins.xml`.
+
+## Mise à niveau vers 1.0.0 de 0.9.6
+
+1.  Supprimer `phonegap-0.9.6.jar` partir du projet `libs` répertoire.
+
+2.  Ajouter `phonegap-1.0.0.jar` au projet `libs` répertoire.
+
+3.  Si vous utilisez Eclipse, veuillez actualiser votre projet Eclipse et faire un nettoyage.
+
+4.  Copiez le nouveau `phonegap-1.0.0.js` dans votre projet.
+
+5.  Mettre à jour votre code HTML pour utiliser le nouveau `phonegap-1.0.0.js` fichier.
+
+6.  Ajouter le `res/xml/plugins.xml` faire correspondre`framework/res/xml/plugins.xml`.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/187a4fe9/docs/fr/3.5.0/guide/platforms/android/webview.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/android/webview.md b/docs/fr/3.5.0/guide/platforms/android/webview.md
new file mode 100644
index 0000000..64f1313
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/android/webview.md
@@ -0,0 +1,110 @@
+---
+
+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.
+---
+
+# Android WebViews
+
+Cette section montre comment intégrer un composant WebView Cordova-activée dans une application Android plus grande. Pour plus d'informations sur la façon dont ces composants peuvent communiquer entre eux, voir Application Plugins.
+
+Si vous n'êtes pas familier avec Android, vous devez tout d'abord vous familiariser avec le Guide de la plate-forme Android et avoir le dernier SDK Android installé avant d'essayer l'option de développement plus inhabituelle d'incorporation une WebView. À partir de 1,9 Cordova, la plateforme Android s'appuie sur un `CordovaWebView` composant, qui s'appuie sur un héritage `CordovaActivity` composant qui est antérieure à la version 1.9.
+
+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 Android.
+
+2.  Accédez à du package Android `/framework` répertoire et exécutez `ant jar` . Il crée le Cordova `.jar` fichier, formé comme`/framework/cordova-x.x.x.jar`.
+
+3.  Copie le `.jar` fichier dans le projet Android `/libs` répertoire.
+
+4.  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" />
+        
+
+5.  Modifier l'activité de sorte qu'il met en œuvre le `CordovaInterface` . Il doit implémenter les méthodes inclus. Vous pouvez les copier de `/framework/src/org/apache/cordova/CordovaActivity.java` , ou bien leur mise en œuvre sur votre propre. Le fragment de code suivant montre une application de base qui s'appuie sur l'interface. 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());
+            }
+        
+
+6.  Si l'application doit utiliser l'appareil photo, mettre en œuvre ce qui suit :
+    
+        @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);
+            }
+        }
+        
+
+7.  Enfin, n'oubliez pas d'ajouter le pool de threads, l'auraient aucun thread sur lequel exécuter des plugins :
+    
+        @Override
+        public ExecutorService getThreadPool() {
+            return threadPool;
+        }
+        
+
+8.  Copiez les fichiers HTML et JavaScript de l'application sur du projet Android `/assets/www` répertoire.
+
+9.  Copie le `config.xml` dossier de `/framework/res/xml` pour le projet `/res/xml` répertoire.
+
+ [1]: http://cordova.apache.org
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/187a4fe9/docs/fr/3.5.0/guide/platforms/blackberry/config.md
----------------------------------------------------------------------
diff --git a/docs/fr/3.5.0/guide/platforms/blackberry/config.md b/docs/fr/3.5.0/guide/platforms/blackberry/config.md
new file mode 100644
index 0000000..338e7bb
--- /dev/null
+++ b/docs/fr/3.5.0/guide/platforms/blackberry/config.md
@@ -0,0 +1,22 @@
+---
+
+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.
+---
+
+# Configuration de blackBerry
+
+BlackBerry souscrit pleinement la [Spécification W3C du Widget][1] ainsi que des extensions propriétaires de RIM. S'il vous plaît voir le complet [BlackBerry WebWorks documentation concernant config.xml][2] pour plus de détails.
+
+ [1]: http://www.w3.org/TR/widgets/
+ [2]: https://developer.blackberry.com/html5/documentation/working_with_config_xml_file_1866970_11.html
\ No newline at end of file


Mime
View raw message