cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [22/51] [partial] docs commit: added 5.4.0 docs for all languages
Date Tue, 10 Nov 2015 03:46:23 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/cordova/storage/sqlresultsetrowlist/sqlresultsetrowlist.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/cordova/storage/sqlresultsetrowlist/sqlresultsetrowlist.md b/www/docs/fr/5.4.0/cordova/storage/sqlresultsetrowlist/sqlresultsetrowlist.md
new file mode 100644
index 0000000..2365443
--- /dev/null
+++ b/www/docs/fr/5.4.0/cordova/storage/sqlresultsetrowlist/sqlresultsetrowlist.md
@@ -0,0 +1,75 @@
+---
+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: SQLResultSetRowList
+---
+
+# SQLResultSetRowList
+
+Une des propriétés de le `[SQLResultSet](../sqlresultset/sqlresultset.html)` contenant les lignes retournées par une requête SQL.
+
+## Propriétés
+
+*   **longueur**: le nombre de lignes retournées par la requête SQL.
+
+## Méthodes
+
+*   **article**: retourne la ligne à l'index spécifié, représenté par un objet JavaScript.
+
+## Détails
+
+Le `SQLResultSetRowList` contient les données retournées à partir d'un SQL `select` déclaration. L'objet contient un `length` propriété indiquant combien de lignes le `select` instruction renvoie. Pour obtenir une ligne de données, appelez la `item` méthode pour spécifier un index. Elle retourne un JavaScript `Object` dont les propriétés sont les colonnes de base de données la `select` instruction a été exécutée dans.
+
+## Plates-formes prises en charge
+
+*   Android
+*   BlackBerry WebWorks (OS 6.0 et supérieur)
+*   iOS
+*   Paciarelli
+
+## Exécuter SQL exemple rapide
+
+    function queryDB(tx) {tx.executeSql ("SELECT * de démo ', [], querySuccess, errorCB);}
+    
+    function querySuccess (tx, résultats) {var len = results.rows.length ;
+            Console.log ("table de démo:" + len + « lignes trouvées. ») ;
+            pour (var j'ai = 0; j'ai < len; i ++) {console.log ("ligne =" + i + "ID =" + results.rows.item (i) .id + "données =" + results.rows.item(i).data) ;
+            }} function errorCB(err) {alert ("erreur lors du traitement SQL:" + err.code) ;
+        } var db = window.openDatabase ("Database", "1.0", "Cordova Demo", 200000) ;
+        DB.transaction (queryDB, errorCB) ;
+    
+
+## Exemple complet
+
+    < !DOCTYPE html >< html >< tête >< titre > stockage exemple < / titre >< script type = "text/javascript" charset = "utf-8" src="cordova.js" >< / script >< script type = "text/javascript" charset = "utf-8" > / / attendre pour les bibliothèques de périphérique API charger / / document.addEventListener ("deviceready", onDeviceReady, false) ;
+    
+        / / Remplir la base de données / / function populateDB(tx) {tx.executeSql ("DROP TABLE IF EXISTS démo") ;
+            tx.executeSql ("créer TABLE IF NOT existe démo (données uniques, id)") ;
+            tx.executeSql (' insérer en démo (id, données) valeurs (1, "première ligne")') ;
+            tx.executeSql ("insérer en démo (id, données) valeurs (2,"Seconde ligne")") ;
+        } / / Interroger la base de données / / function queryDB(tx) {tx.executeSql ("SELECT * de démo ', [], querySuccess, errorCB) ;
+        } / / Interroger le rappel réussi / / function querySuccess (tx, résultats) {var len = results.rows.length ;
+            Console.log ("table de démo:" + len + « lignes trouvées. ») ;
+            pour (var j'ai = 0; j'ai < len; i ++) {console.log ("ligne =" + i + "ID =" + results.rows.item (i) .id + "données =" + results.rows.item(i).data) ;
+            }} / / Rappel erreur de transaction / / function errorCB(err) {console.log ("erreur lors du traitement SQL:" + err.code) ;
+        } / / Rappel réussi de transaction / / function successCB() {var db = window.openDatabase ("Database", "1.0", "Cordova Demo", 200000) ;
+            DB.transaction (queryDB, errorCB) ;
+        } / / périphérique API sont disponibles / / function onDeviceReady() {var db = window.openDatabase ("Database", "1.0", "Cordova Demo", 200000) ;
+            DB.transaction (populateDB, errorCB, successCB) ;
+        } < /script >< / chef >< corps >< h1 > exemple < / h1 >< p > base de données < /p >< / body >< / html >
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/cordova/storage/sqltransaction/sqltransaction.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/cordova/storage/sqltransaction/sqltransaction.md b/www/docs/fr/5.4.0/cordova/storage/sqltransaction/sqltransaction.md
new file mode 100644
index 0000000..91690ef
--- /dev/null
+++ b/www/docs/fr/5.4.0/cordova/storage/sqltransaction/sqltransaction.md
@@ -0,0 +1,111 @@
+---
+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: SQLTransaction
+---
+
+# SQLTransaction
+
+Permet l'exécution d'instructions SQL sur la base de données.
+
+## Méthodes
+
+*   **executeSql**: exécute une instruction SQL.
+
+## Détails
+
+Appeler une `Database` méthode de transaction de l'objet, passe un `SQLTransaction` objet à la méthode de rappel spécifiée.
+
+## Plates-formes prises en charge
+
+*   Android
+*   BlackBerry WebWorks (OS 6.0 et supérieur)
+*   iOS
+*   Paciarelli
+
+## Exécuter SQL exemple rapide
+
+    function populateDB(tx) {
+        tx.executeSql('DROP TABLE IF EXISTS DEMO');
+        tx.executeSql('CREATE TABLE IF NOT EXISTS DEMO (id unique, data)');
+        tx.executeSql('INSERT INTO DEMO (id, data) VALUES (1, "First row")');
+        tx.executeSql('INSERT INTO DEMO (id, data) VALUES (2, "Second row")');
+    }
+    
+    function errorCB(err) {
+        alert("Error processing SQL: "+err);
+    }
+    
+    function successCB() {
+        alert("success!");
+    }
+    
+    var db = window.openDatabase("Database", "1.0", "Cordova Demo", 200000);
+    db.transaction(populateDB, errorCB, successCB);
+    
+
+## Exemple complet
+
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>Storage Example</title>
+    
+        <script type="text/javascript" charset="utf-8" src="cordova.js"></script>
+        <script type="text/javascript" charset="utf-8">
+    
+        // Wait for device API libraries to load
+        //
+        document.addEventListener("deviceready", onDeviceReady, false);
+    
+        // device APIs are available
+        //
+        function onDeviceReady() {
+            var db = window.openDatabase("Database", "1.0", "Cordova Demo", 200000);
+            db.transaction(populateDB, errorCB, successCB);
+        }
+    
+        // Populate the database
+        //
+        function populateDB(tx) {
+            tx.executeSql('DROP TABLE IF EXISTS DEMO');
+            tx.executeSql('CREATE TABLE IF NOT EXISTS DEMO (id unique, data)');
+            tx.executeSql('INSERT INTO DEMO (id, data) VALUES (1, "First row")');
+            tx.executeSql('INSERT INTO DEMO (id, data) VALUES (2, "Second row")');
+        }
+    
+        // Transaction error callback
+        //
+        function errorCB(err) {
+            alert("Error processing SQL: "+err);
+        }
+    
+        // Transaction success callback
+        //
+        function successCB() {
+            alert("success!");
+        }
+    
+        </script>
+      </head>
+      <body>
+        <h1>Example</h1>
+        <p>SQLTransaction</p>
+      </body>
+    </html>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/cordova/storage/storage.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/cordova/storage/storage.md b/www/docs/fr/5.4.0/cordova/storage/storage.md
new file mode 100644
index 0000000..cb7f1f6
--- /dev/null
+++ b/www/docs/fr/5.4.0/cordova/storage/storage.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.
+
+title: Stockage
+---
+
+# Stockage
+
+> Un aperçu des options de stockage pour Cordova.
+
+Stockage de plusieurs API sont disponibles pour des applications de Cordova. Voir [html5rocks][1]. pour une présentation plus complète et des exemples.
+
+ [1]: http://www.html5rocks.com/en/features/storage
+
+## LocalStorage
+
+Aussi connu comme *stockage web*, *stockage simple*, ou par son interface de rechange *stockage de session* , cette API permet le stockage de paire clé/valeur synchrone et est disponible dans les implémentations sous-jacentes WebView. Reportez-vous à [la spécification W3C][2] pour plus de détails.
+
+ [2]: http://www.w3.org/TR/webstorage/
+
+## WebSQL
+
+Cette API est disponible dans le mode Web sous-jacent. La [Spécification de base de données SQL Web][3] propose plusieurs tables de base de données complète accessible via des requêtes SQL.
+
+ [3]: http://dev.w3.org/html5/webdatabase/
+
+Les plates-formes suivantes prennent en charge les WebSQL :
+
+*   Android
+*   BlackBerry 10
+*   iOS
+*   Paciarelli
+
+## IndexedDB
+
+Cette API est disponible dans le mode Web sous-jacent. [Indexed DB][4] offre plus de fonctionnalités que LocalStorage, mais moins de WebSQL.
+
+ [4]: http://www.w3.org/TR/IndexedDB/
+
+Les plates-formes suivantes prennent en charge IndexedDB :
+
+*   BlackBerry 10
+*   Firefox OS
+*   Windows Phone 8
+*   Windows 8
+
+## Options fondées sur le plugin
+
+Outre le stockage Qu'api énumérées ci-dessus, [Fichier API][5] vous permet de données en cache sur le système de fichiers local. Autres [plugins Cordova][6] offrent des options de rangement similaires.
+
+ [5]: https://github.com/apache/cordova-plugin-file/blob/master/doc/index.md
+ [6]: http://plugins.cordova.io/
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/cordova/storage/storage.opendatabase.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/cordova/storage/storage.opendatabase.md b/www/docs/fr/5.4.0/cordova/storage/storage.opendatabase.md
new file mode 100644
index 0000000..f0680ec
--- /dev/null
+++ b/www/docs/fr/5.4.0/cordova/storage/storage.opendatabase.md
@@ -0,0 +1,72 @@
+---
+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: openDatabase
+---
+
+# openDatabase
+
+Retourne un nouveau `Database` objet.
+
+    var dbShell = window.openDatabase(database_name, database_version, database_displayname, database_size);
+    
+
+## Description
+
+La méthode crée une nouvelle base de données du Lite de SQL et retourne un `Database` objet permettant la manipulation des données.
+
+## Plates-formes prises en charge
+
+*   Android
+*   BlackBerry WebWorks (OS 6.0 et supérieur)
+*   iOS
+*   Paciarelli
+
+## Petit exemple
+
+    var db = window.openDatabase("test", "1.0", "Test DB", 1000000);
+    
+
+## Exemple complet
+
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>Storage Example</title>
+    
+        <script type="text/javascript" charset="utf-8" src="cordova.js"></script>
+        <script type="text/javascript" charset="utf-8">
+    
+        // Wait for device API libraries to load
+        //
+        document.addEventListener("deviceready", onDeviceReady, false);
+    
+        // device APIs are available
+        //
+        function onDeviceReady() {
+            var db = window.openDatabase("test", "1.0", "Test DB", 1000000);
+        }
+    
+        </script>
+      </head>
+      <body>
+        <h1>Example</h1>
+        <p>Open Database</p>
+      </body>
+    </html>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/guide/appdev/hooks/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/guide/appdev/hooks/index.md b/www/docs/fr/5.4.0/guide/appdev/hooks/index.md
new file mode 100644
index 0000000..e2208ff
--- /dev/null
+++ b/www/docs/fr/5.4.0/guide/appdev/hooks/index.md
@@ -0,0 +1,260 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Guide de crochets
+---
+
+# Guide de crochets
+
+Cordova Hooks représentent des scripts spéciaux qui pourraient être ajoutées par application et développeurs de plugins ou même par votre propre build system pour personnaliser les commandes de cordova. Scripts de hook pourraient être définies en les ajoutant au dossier prédéfini spécial (`/hooks`) ou via des fichiers de configuration (`config.xml` et `plugin.xml`) et exécuter en série dans l'ordre suivant :
+
+  * Crochets de demande de `/hooks`;
+  * Application des crochets de `config.xml`;
+  * Crochets de plugin de `plugins/.../plugin.xml`.
+
+**Remarque**: `/hooks` répertoire est considérée comme dépréciée en faveur des éléments crochet dans config.xml et plugin.xml.
+
+## Types de prise en charge de crochet
+
+Les types suivants de crochet sont pris en charge :
+
+    after_build
+    after_compile
+    after_clean
+    after_docs
+    after_emulate
+    after_platform_add
+    after_platform_rm
+    after_platform_ls
+    after_plugin_add
+    after_plugin_ls
+    after_plugin_rm
+    after_plugin_search
+    after_plugin_install // Plugin hooks in plugin.xml are executed for a plugin being installed only
+    after_prepare
+    after_run
+    after_serve
+    before_build
+    before_clean
+    before_compile
+    before_docs
+    before_emulate
+    before_platform_add
+    before_platform_rm/
+    before_platform_ls
+    before_plugin_add
+    before_plugin_ls
+    before_plugin_rm
+    before_plugin_search/
+    before_plugin_install // Plugin hooks in plugin.xml are executed for a plugin being installed only
+    before_plugin_uninstall // Plugin hooks in plugin.xml are executed for a plugin being uninstalled only
+    before_prepare
+    before_run
+    before_serve
+    pre_package // Windows and Windows Phone only
+    
+
+## Façons de définir des crochets
+
+### Via `/hooks` répertoire
+
+**Note**: cette méthode est considérée comme dépréciée en faveur des éléments crochet dans config.xml et plugin.xml.
+
+Pour exécuter l'action personnalisée lorsque le type de crochet correspondant est déclenché, utilisez le type de crochet comme nom pour un sous-dossier à l'intérieur du répertoire « crochets », placez vous le script file ici, par exemple :
+
+    # script file will be automatically executed after each build
+    hooks/after_build/after_build_custom_action.js
+    
+
+Lorsque vous utilisez ces crochets, ils seront toujours exécutés sous forme de fichiers exécutables, pas en tant que modules chargeables de JavaScript. **N'oubliez pas**: faites vos scripts exécutables dans ce cas.
+
+### Config.Xml
+
+Crochets peuvent être définis dans le `fichier config.xml` en utilisant `< hook >` éléments, par exemple de projet :
+
+    <hook type="before_build" src="scripts/appBeforeBuild.bat" />
+    <hook type="before_build" src="scripts/appBeforeBuild.js" />
+    <hook type="before_plugin_install" src="scripts/appBeforePluginInstall.js" />
+    
+    <platform name="wp8">
+        <hook type="before_build" src="scripts/wp8/appWP8BeforeBuild.bat" />
+        <hook type="before_build" src="scripts/wp8/appWP8BeforeBuild.js" />
+        <hook type="before_plugin_install" src="scripts/wp8/appWP8BeforePluginInstall.js" />
+        ...
+    </platform>
+    
+    <platform name="windows8">
+        <hook type="before_build" src="scripts/windows8/appWin8BeforeBuild.bat" />
+        <hook type="before_build" src="scripts/windows8/appWin8BeforeBuild.js" />
+        <hook type="before_plugin_install" src="scripts/windows8/appWin8BeforePluginInstall.js" />
+        ...
+    </platform>
+    
+
+### Crochets de plugin (plugin.xml)
+
+Comme un développeur de plugin, que vous pouvez définir des scripts à l'aide des éléments `< hook >` dans un `plugin.xml` comme ça hook :
+
+    <hook type="before_plugin_install" src="scripts/beforeInstall.js" />
+    <hook type="after_build" src="scripts/afterBuild.js" />
+    
+    <platform name="wp8">
+        <hook type="before_plugin_install" src="scripts/wp8BeforeInstall.js" />
+        <hook type="before_build" src="scripts/wp8BeforeBuild.js" />
+        ...
+    </platform>
+    
+
+`before_plugin_install`, `after_plugin_install`, `before_plugin_uninstall` plugin crochets seront tirés exclusivement pour le plugin installé/désinstallé.
+
+## Interface de script
+
+### Javascript
+
+Si vous rédigez des crochets à l'aide de Node.js, vous devez utiliser la définition suivante du module :
+
+```javascript
+module.exports = function(context) {
+    ...
+}
+```
+
+Vous pouvez faire votre async de scripts à l'aide de q :
+
+```javascript
+module.exports = function(context) {
+    var Q = context.requireCordovaModule('q');
+    var deferral = new Q.defer();
+
+    setTimeout(function(){
+      console.log('hook.js>> end');
+    deferral.resolve();
+    }, 1000);
+
+    return deferral.promise;
+}
+```
+
+objet de `context` contient le type de crochet, chemin d'accès complet du script exécuté, les options crochet, les arguments de ligne de commande passés à Cordoue et objet de premier niveau "cordova" :
+
+```json
+{
+  "hook": "before_plugin_install",
+  "scriptLocation": "c:\\script\\full\\path\\appBeforePluginInstall.js",
+  "cmdLine": "The\\exact\\command\\cordova\\run\\with arguments",
+  "opts": {
+    "projectRoot":"C:\\path\\to\\the\\project",
+    "cordova": {
+      "platforms": ["wp8"],
+      "plugins": ["com.plugin.withhooks"],
+      "version": "0.21.7-dev"
+    },
+    "plugin": {
+      "id": "com.plugin.withhooks",
+      "pluginInfo": {
+        ...
+      },
+      "platform": "wp8",
+      "dir": "C:\\path\\to\\the\\project\\plugins\\com.plugin.withhooks"
+    }
+  },
+  "cordova": {...}
+}
+
+```
+
+`Context.opts.plugin` objet se répercutera seulement aux scripts de crochets de plugin.
+
+Vous pouvez également exiger des modules supplémentaires de Cordova dans votre script à l'aide de `context.requireCordovaModule` de la manière suivante :
+
+```javascript
+var Q = context.requireCordovaModule('q');
+```
+
+**Note**: nouvelle interface de script chargeur de module est utilisé pour les fichiers `.js` définis via `config.xml` ou `plugin.xml` seulement. Pour des raisons de compatibilité crochet fichiers spécifiés par l'intermédiaire de `/hooks` dossiers sont gérés via le nœud child_process frayer, voir "Non-javascript" la section ci-dessous.
+
+### Non-javascript
+
+**Note**: nous recommandons fortement d'écrire vos hameçons à l'aide de Node.js, afin qu'ils soient multi-plateforme, voir la section "Javascript" ci-dessus.
+
+Non-javascript scripts sont exécutés via spawn child_process nœud de répertoire racine du projet et ont les passes de répertoire racine comme premier argument. Toutes les autres options sont transmises au script à l'aide de variables d'environnement :
+
+  * CORDOVA_VERSION - la version CLI-Cordova.
+  * CORDOVA_PLATFORMS - liste des plates-formes auquel s'applique la commande séparées par une virgule (p. ex.: android, ios).
+  * CORDOVA_PLUGINS - liste des plugin ID auquel s'applique la commande séparées par une virgule (p. ex.: org.apache.cordova.file, org.apache.cordova.file-transfert)
+  * CORDOVA_HOOK - chemin d'accès au crochet qui est en cours d'exécution.
+  * CORDOVA_CMDLINE - les arguments de ligne de commande exactes passés à cordova (p. ex.: cordova exécuter ios--émuler)
+
+Si un script retourne un code de sortie différent de zéro, puis la commande de cordova parent est interrompue.
+
+Notez également que même si vous travaillez sous Windows, et dans le cas où vos scripts de hook ne sont pas des fichiers bat (ce qui est recommandé, si vous souhaitez que vos scripts pour travailler dans les systèmes d'exploitation autres que Windows) Cordova CLI attendra une ligne shebang comme la première ligne pour qu'il puisse connaître l'interprète, il faut utiliser pour lancer le script. La ligne de shebang doit correspondre à l'exemple suivant :
+
+    #!/usr/bin/env [name_of_interpreter_executable]
+    
+
+## Exemple d'utilisation
+
+Cet exemple montre l'utilisation de crochets Cordova à la trace à la sortie de la console la taille du fichier .apk généré pour la plateforme Android.
+
+Créer le vide Cordova app et ajouter la définition suivante au `fichier config.xml` pour dire Cordova pour exécuter le script `afterBuild.js` après chaque génération de plate-forme.
+
+    <hook type="after_build" src="scripts/afterBuild.js" />
+    
+
+Créer le fichier `scripts/afterBuild.js` et ajoutez l'implémentation suivante. Nous utilisons la version asynchrone de la méthode `fs.stat` afin de démontrer comment les fonctionnalités asynchrones pourraient être faite par l'intermédiaire de crochets.
+
+    module.exports = function(ctx) {
+        // make sure android platform is part of build 
+        if (ctx.opts.platforms.indexOf('android') < 0) {
+            return;
+        }
+        var fs = ctx.requireCordovaModule('fs'),
+            path = ctx.requireCordovaModule('path'),
+            deferral = ctx.requireCordovaModule('q').defer();
+    
+        var platformRoot = path.join(ctx.opts.projectRoot, 'platforms/android');
+        var apkFileLocation = path.join(platformRoot, 'build/outputs/apk/android-debug.apk');
+    
+        fs.stat(apkFileLocation, function(err,stats) {
+            if (err) {
+                 deferral.reject('Operation failed');
+            } else {
+                console.log('Size of ' + apkFileLocation + ' is ' + stats.size +' bytes');
+                deferral.resolve();
+            }
+        });
+    
+        return deferral.promise;
+    };
+    
+
+Paramètre `ctx` dans l'exemple ci-dessus est passée de Cordova et représente le contexte d'exécution tels que le chemin d'accès complet du script, plateforme cible, les arguments de ligne de commande, etc. et expose également les fonctionnalités d'assistance supplémentaires. Voir la section `Interface de Script` ci-dessus pour plus de détails.
+
+Vous pouvez maintenant ajouter la plateforme android et exécuter la build.
+
+    cordova platform add android
+    ..
+    cordova build
+    ..
+    Size of path\to\app\platforms\android\build\outputs\apk\android-debug.apk is 1821193 bytes
+    
+
+Autres exemples de bon usage peuvent être trouvés ici :
+
+<http://devgirl.org/2013/11/12/three-hooks-your-cordovaphonegap-project-needs/>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/guide/appdev/privacy/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/guide/appdev/privacy/index.md b/www/docs/fr/5.4.0/guide/appdev/privacy/index.md
new file mode 100644
index 0000000..48ccbe1
--- /dev/null
+++ b/www/docs/fr/5.4.0/guide/appdev/privacy/index.md
@@ -0,0 +1,60 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Guide de la vie privée
+---
+
+# Guide de la vie privée
+
+La confidentialité sur mobile est une question essentielle que chaque développeur d'application doit considérer. Vos utilisateurs s'attendent à ce que leurs renseignements personnels soient recueillis et traités de manière appropriée par votre application. En outre, il y a un nombre croissant de juridictions qui ont maintenant des exigences légales concernant les pratiques de confidentialité mobile.
+
+Ce guide sur la vie privée dans les applications mobiles devrait être considéré comme un *manuel* qui adresse les problèmes les plus importants. Il décrit certaines bonnes pratiques globalement reconnues et fournit des références à d'autres guides et références plus détaillés.
+
+*   **Politique de confidentialité**: vous app devrait inclure une politique de confidentialité qui traite de sujets tels que quel type d'information l'app recueille auprès ou au sujet de vos utilisateurs, comment cette information est utilisée, avec lesquels il est partagé, et comment les utilisateurs peuvent faire des choix relatifs à la vie privée au sein de l'app. Pour faciliter la compréhension, vous devez utiliser un langage simple et éviter le jargon technique. Vous devriez rendre disponible votre politique de confidentialité aux utilisateurs pour qu'ils puissent la consulter avant le téléchargement, comme dans la description de l'app dans la Galerie d'apps. En outre, vous devez rendre disponible votre politique de confidentialité directement dans l'application elle-même. La taille réduite des périphériques mobiles crée des difficultés pour afficher les politiques de confidentialité aux utilisateurs. Envisager l'élaboration d'une *version abrégée* de la
  politique qui inclut l'information la plus importante et ensuite fournir un lien vers la politique « complète » pour ceux qui s'y intéressent de façon plus détaillée. Plusieurs groupes tentent d'élaborer des normes de base concernant les icônes pour la communication des pratiques de confidentialité, que vous voudrez peut-être consulter une fois que ces normes seront prêtes.
+
+*   **Collecte d'informations sensibles** : la collecte d'informations personnelles sensibles dans l'application soulève des préoccupations importantes concernant la vie privée. Exemples de renseignements personnels sensibles comprennent des renseignements financiers, des informations de santé et des informations au sujet des enfants. Il comprend également des informations recueillies auprès de certains capteurs et bases de données qui se trouvent généralement sur les appareils mobiles et tablettes, telles que des informations de géolocalisation, contacts/annuaire téléphonique, microphone/appareil photo et photos ou vidéos stockées. Voir les pages suivantes de la documentation pour plus d'informations : [appareil photo][1], [capture][2], [contacts][3]et [géolocalisation][4]. En règle générale, vous devez obtenir l'autorisation express de l'utilisateur avant de recueillir des informations sensibles et, si possible, fournir un mécanisme de contrôle qui vous permett
 e de facilement modifier les autorisations. Les systèmes d'exploitation des applications peuvent aider dans certains cas par la présentation de boîtes de dialogue qui demandent au moment opportun la permission de l'utilisateur avant la collecte d'information. Dans ces cas, n'oubliez pas de profiter de toute occasion pour personnaliser le texte de la boîte de dialogue afin de préciser comment l'application utilise et, le cas échéant, partage ces informations.
+
+*   **Éviter la surprise de l'utilisateur**: si l'application recueille ou utilise les informations d'une manière qui peut être surprenante pour les utilisateurs à la lumière de l'objectif principal de votre application (par exemple, un lecteur de musique qui accède à des photos stockées), vous devez prendre des mesures analogues comme pour la collecte de renseignements personnels sensibles. En d'autres termes, vous devez fortement envisager l'utilisation de boîtes de dialogue pour informer au moment opportun l'utilisateur de la collecte ou l'utilisation de ces informations et, le cas échéant, fournir un contrôle de confidentialité correspondant.
+
+*   **Collecte de données de tiers ou de partage**: Si vous app collecte des informations qui sont fournies à une autre société--comme une plateforme de réseau social ou d'un réseau publicitaire (par exemple, si votre application affiche des publicités)--vous devez informer vos utilisateurs de cette collecte et de ce partage. Au minimum, votre politique de confidentialité devrait décrire la collecte de l'information et de partage et, le cas échéant, offrir à vos utilisateurs la capacité de contrôle ou de désengagement de cette collecte ou ce partage.
+
+*   **Sécurité et limitation de la collecte** : vos utilisateurs confient à votre application leurs informations et ils attendent que vous preniez des précautions de sécurité appropriées pour les protéger. Un des meilleurs moyens de ne pas compromettre la sécurité des renseignements personnels est ne pas collecter les informations en premier lieu, à moins que votre application ait une raison spécifique et légitime pour cette collecte. Pour les informations qui n'ont pas besoin d'être recueillies, assurez-vous de fournir des contrôles de sécurité appropriés pour protéger ces informations, si elles sont stockées sur l'appareil ou sur vos serveurs back-end. Vous devez également développer une stratégie de rétention de données appropriée qui est mis en œuvre au sein de l'app et sur vos serveurs back-end.
+
+ [1]: cordova_camera_camera.md.html
+ [2]: cordova_media_capture_capture.md.html
+ [3]: cordova_contacts_contacts.md.html
+ [4]: cordova_geolocation_geolocation.md.html
+
+Voici quelques guides de confidentialité mobile utile pour les développeurs :
+
+*   Procureur général de la Californie, [Privacy on the Go: Recommandations for the Mobile Ecosystem][5]
+
+*   Center for Democracy & Technology, Future of Privacy Forum, [Best Practices for Mobile App Developers][6]
+
+*   CTIA-The Wireless Association, [Practices and Guidelines for Location Based Services][7]
+
+*   Federal Trade Commission, [Mobile Privacy Disclosures: Building Trust Through Transparency][8]
+
+*   Future of Privacy Forum, site web de l'[Application Privacy][9]
+
+ [5]: http://oag.ca.gov/sites/all/files/pdfs/privacy/privacy_on_the_go.pdf
+ [6]: http://www.futureofprivacy.org/wp-content/uploads/Best-Practices-for-Mobile-App-Developers_Final.pdf
+ [7]: http://www.ctia.org/business_resources/wic/index.cfm/AID/11300
+ [8]: http://www.ftc.gov/os/2013/02/130201mobileprivacyreport.pdf
+ [9]: http://www.applicationprivacy.org
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/guide/appdev/security/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/guide/appdev/security/index.md b/www/docs/fr/5.4.0/guide/appdev/security/index.md
new file mode 100644
index 0000000..4315ed3
--- /dev/null
+++ b/www/docs/fr/5.4.0/guide/appdev/security/index.md
@@ -0,0 +1,108 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Guide de sécurité
+---
+
+# Guide de sécurité
+
+Le guide suivant contient quelques meilleures pratiques de sécurité que vous devriez considérer lors du développement d'une application de Cordova. S'il vous plaît être conscient que la sécurité est un sujet très compliqué et c'est pourquoi ce guide n'est pas exhaustif. Si vous croyez que vous pouvez contribuer à ce guide, s'il vous plaît n'hésitez pas à déposer une question au traqueur de bogue de Cordova sous ["Documentation"][1]. Ce guide est conçu pour être applicable au développement général de Cordova (toutes plates-formes), mais on notera des considérations particulières spécifiques à la plateforme.
+
+ [1]: https://issues.apache.org/jira/browse/CB/component/12316407
+
+## Ce guide aborde les sujets suivants :
+
+*   Liste blanche
+*   Iframes et le mécanisme de rappel Id
+*   Certificat épinglage
+*   Les certificats auto-signés
+*   [Stockage](../../../cordova/storage/storage.html) crypté
+*   Conseils généraux
+*   Articles recommandés et autres ressources
+
+## Liste blanche
+
+*   Lire et comprendre le Guide liste blanche
+
+*   Domaine liste blanche ne fonctionne pas sur Android API 10 et en dessous et WP8 pour iframes et XMLHttpRequest. Autrement dit, un attaquant peut charger n'importe quel domaine dans un iframe et tout script sur cette page au sein de l'iframe peut accéder directement à Cordova JavaScript objets et les objets de Java natives correspondantes. Prenez cela en considération lors de la génération d'applications pour ces plateformes. En pratique, cela signifie veiller à ce que vous ciblez un Android API supérieur à 10, et si possible ne pas utiliser un iframe pour charger le contenu externe - utilisent le plugin d'inAppBrowser ou d'autres plugins tiers.
+
+## Iframes et le mécanisme de rappel Id
+
+Si le contenu est servi dans une iframe d'un domaine dans la liste blanche, ce domaine auront accès au pont de Cordova native. Cela signifie que si vous liste blanche un réseau publicitaire de tierce partie et servir ces annonces via un iframe, il est possible qu'une annonce malveillant sera en mesure de sortir de l'iframe et effectuer des actions malveillantes. Pour cette raison, vous devez généralement pas utiliser iframes à moins que vous contrôlez le serveur qui héberge le contenu de l'iframe. Notez également qu'il existe des plugins tiers disponibles pour soutenir les réseaux de publicité. Notez que cette instruction n'est pas vraie pour iOS, qui intercepte tout, y compris les connexions de l'iframe.
+
+## Certificat épinglage
+
+Cordova ne supporte pas le vrai certificat épinglage. Le principal obstacle à cela est un manque d'API natives dans Android d'interception des connexions SSL pour effectuer la vérification du certificat du serveur. (Même si il est possible de de certificat épinglage sur Android en Java à l'aide de la JSSE, le mode Web sur Android est écrit en C++ et connexions au serveur sont gérées pour vous par le webview, donc il n'est pas possible d'utiliser Java et JSSE là.) Depuis Apache Cordova est destinée à offrir une API cohérente sur plusieurs plateformes, n'ayant ne pas une capacité dans une plateforme importante casse que l'uniformité.
+
+Il y a des façons de rapprocher l'épinglage de certificat, par exemple, vérifier la que clé publique du serveur (empreinte digitale) est la valeur attendue lorsque votre application démarre ou à d'autres moments différents au cours de la durée de vie de votre application. Il y a des plugins tiers disponibles pour Cordova qui peut le faire. Cependant, ce n'est pas la même chose que le vrai certificat épinglage qui vérifie automatiquement la valeur attendue à chaque connexion au serveur.
+
+## Les certificats auto-signés
+
+Il n'est pas recommandé d'utiliser des certificats auto-signés sur votre serveur. Si tu désires SSL, il est fortement recommandé que votre serveur possède un certificat qui a été dûment signé par une CA connue (autorité de certification). L'incapacité de vrai certificat épinglage fait c'est important.
+
+La raison est qu'accepter les certificats auto-signés contourne la validation de chaîne de certificat, qui permet à n'importe quel certificat de serveur à être considéré comme valide par l'appareil. Cela ouvre la communication aux attaques man-in-the-middle. Il devient très facile pour un pirate d'intercepter et de lire toutes les communications entre l'appareil et le serveur non seulement, mais aussi à modifier la communication. L'appareil ne saura jamais que ce qui se passe parce qu'il ne vérifie pas que le certificat du serveur est signé par une autorité de certification approuvée. Le dispositif n'a aucune preuve que le serveur est qui elle attend. En raison de la facilité de faire une attaque man-in-the-middle, acceptant des certificats auto-signés est seulement marginalement mieux que juste en cours d'exécution http au lieu de https sur un réseau non approuvé. Oui, le trafic devrait être crypté, mais il pourrait être cryptée avec la clé d'un man-in-the-mi
 ddle, donc le man-in-the-middle peut accéder à tout, si le chiffrement est inutile sauf pour des observateurs passifs. Utilisateurs confiance SSL pour être sûr, et cela délibérément rendrait il précaires, donc l'utilisation SSL devienne trompeuse. Si cela doit être utilisé sur un réseau fiable (c'est-à-dire, vous êtes tout à fait à l'intérieur d'une entreprise contrôlée), puis les certificats auto-signés ne sont pas toujours recommandées. Les deux recommandations dans un réseau de confiance sont simplement utiliser http parce que le réseau lui-même est approuvé, ou d'obtenir un certificat signé par une autorité de certification (ne pas self-signed). Le réseau est approuvé ou il ne l'est pas.
+
+Les principes décrits ici ne sont pas spécifiques à Apache Cordova, elles s'appliquent à toutes les communications client-serveur.
+
+Lorsque vous exécutez Cordova sur Android, à l'aide de `android:debuggable="true"` dans la demande manifeste permettra Erreurs SSL par exemple certificat les erreurs de validation de chaîne sur les certificats auto-signés. Vous pouvez donc utiliser des certificats auto-signés dans cette configuration, mais ce n'est pas une configuration qui doit être utilisée lorsque votre application est en production. Il est destiné à être utilisé uniquement pendant le développement d'applications.
+
+## Stockage crypté
+
+(À DÉTERMINER)
+
+## Conseils généraux
+
+### Ne pas utiliser Android Gingerbread !
+
+*   Définissez votre niveau min-cible-sdk supérieure à 10. 10 API est le pain d'épices et pain d'épice n'est plus supporté par les fabricants de Google ou de dispositif et n'est donc pas recommandé par l'équipe de Cordova. 
+*   Pain d'épice s'est avéré être précaire et un des plus ciblés mobile OSs [http://www.mobilemag.com/2012/11/06/andriod-2-3-gingerbread-security/][2]. 
+*   La liste blanche sur Android ne fonctionne pas avec le pain d'épice ou inférieur. Autrement dit, qu'un attaquant peut charger un code malveillant dans un iframe qui aurait accès à l'ensemble des APIs Cordova et pourrait utiliser cet accès pour dérober des données personnelles, envoyer des messages SMS à des numéros surtaxés et effectuer d'autres actes de violence. 
+
+ [2]: http://bgr.com/2012/11/06/android-security-gingerbread-malware/
+
+### Utiliser InAppBrowser pour les liens externes
+
+*   Utilisez le InAppBrowser lors de l'ouverture des liens vers tout site Web extérieur. C'est beaucoup plus sûr que la liste blanche, un nom de domaine et y compris le contenu directement dans votre application, car le InAppBrowser utilisera les fonctions de sécurité du navigateur natif et ne donnera pas le site Web de l'accès à votre environnement de Cordova. Même si vous faites confiance au site tiers incluez directement dans votre application, le site Web de cette tierce partie pourrait relier au contenu web malveillant. 
+
+### Valider l'entrée d'utilisateur toutes les
+
+*   Toujours valider toutes les entrées qui accepte votre demande. Cela inclut les noms d'utilisateur, mots de passe, dates, médias téléchargés, etc.. Parce qu'un attaquant pourrait manipuler vos biens HTML et JS (que ce soit par la décompilation de votre application ou à l'aide des outils de débogage comme chrome://inspect), cette validation doit également être effectuée sur votre serveur, surtout avant le transfert des données vers n'importe quel service de back-end. 
+*   Autres sources où les données doivent être validées : documents de l'utilisateur, contacts, avis de Poussée
+
+### Ne pas mettre en cache les données sensibles
+
+*   Si les noms d'utilisateur, mot de passe, informations de géolocalisation et autres données sensibles est mis en cache, puis il pourrait potentiellement être récupéré plus tard par une application ou un utilisateur non autorisé.
+
+### Ne pas utiliser eval(), sauf si vous savez ce que vous faites
+
+*   Le JavaScript fonction eval() a une longue histoire d'abus. Utilisation incorrecte peut ouvrir votre code pour les attaques par injection, débogage des difficultés et l'exécution de code plus lente. 
+
+### Ne supposez pas que votre code source est sécurisé
+
+*   Depuis une application de Cordova est construite à partir de HTML et JavaScript actif qui obtenir emballé dans un contenant natif, vous devriez considérer pas votre code pour être sûr. Il est possible de désosser une application de Cordova. 
+
+## Articles recommandés et autres ressources
+
+*   [Antisèche HTML5 sécurité, détaillant comment sécuriser votre application HTML5][3]
+*   [Article de PhoneGap sur la sécurité des périphériques, telles que l'utilisation des données chiffrées][4]
+*   [Hybride applications basées sur le livre blanc sur des failles de sécurité connues dans Webview][5]
+
+ [3]: https://www.owasp.org/index.php/HTML5_Security_Cheat_Sheet
+ [4]: https://github.com/phonegap/phonegap/wiki/Platform-Security
+ [5]: http://www.cis.syr.edu/~wedu/Research/paper/webview_acsac2011.pdf
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/guide/appdev/whitelist/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/guide/appdev/whitelist/index.md b/www/docs/fr/5.4.0/guide/appdev/whitelist/index.md
new file mode 100644
index 0000000..b6f4077
--- /dev/null
+++ b/www/docs/fr/5.4.0/guide/appdev/whitelist/index.md
@@ -0,0 +1,145 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Guide de la liste blanche
+---
+
+# Guide de la liste blanche
+
+Domaine liste blanche est un modèle de sécurité qui contrôle l'accès à des domaines externes sur lesquels votre application n'a aucun contrôle. Cordova fournit une stratégie de sécurité configurables pour définir quels sites externes sont accessibles. Par défaut, de nouvelles applications sont configurées pour autoriser l'accès à n'importe quel site. Avant de déplacer votre application à la production, vous devez formuler une liste blanche et permettre l'accès au réseau des domaines et sous-domaines.
+
+Pour Android et iOS (à partir de leurs 4,0 versions), politique de sécurité de Cordova est extensible via une interface plugin. Votre application doit utiliser le [cordova-plugin-whitelist][1], car il fournit la meilleure sécurité et configurabilité que les versions précédentes de Cordova. Bien qu'il soit possible d'implémenter votre propre plugin whitelist, il n'est pas recommandée à moins que votre application a des besoins de politique de sécurité très spécifiques. Voir le [cordova-plugin-whitelist][1] pour plus de détails sur son utilisation et de configuration.
+
+ [1]: https://github.com/apache/cordova-plugin-whitelist
+
+Pour d'autres plateformes, Cordova respecte la spécification [W3C Widget accès][2], qui se fonde sur l'élément `< access >` dans le fichier `config.xml` du PPA pour activer l'accès réseau à des domaines spécifiques. Pour les projets qui s'appuient sur le workflow de CLI décrit dans l'Interface de ligne de commande, ce fichier se trouve dans le répertoire racine du projet. Autrement pour les chemins de développement spécifiques à la plateforme, les endroits sont énumérés dans les sections ci-dessous. (Voir les différents Guides de plate-forme pour plus d'informations sur chaque plate-forme).
+
+ [2]: http://www.w3.org/TR/widgets-access/
+
+Les exemples suivants illustrent la syntaxe de `< access >` liste blanche :
+
+*   Accès à [google.com][3]:
+    
+        <access origin="http://google.com" />
+        
+
+*   Accès sécurisé [google.com][4] ( `https://` ) :
+    
+        <access origin="https://google.com" />
+        
+
+*   Accès pour le sous-domaine [maps.google.com][5]:
+    
+        <access origin="http://maps.google.com" />
+        
+
+*   Accès à tous les sous-domaines sur [google.com][3], par exemple [mail.google.com][6] et [docs.google.com][7]:
+    
+        <access origin="http://*.google.com" />
+        
+
+*   Accès à *tous les* domaines, par exemple, [google.com][3] et [developer.mozilla.org][8]:
+    
+        <access origin="*" />
+        
+    
+    C'est la valeur par défaut pour les projets CLI nouvellement créés.
+
+ [3]: http://google.com
+ [4]: https://google.com
+ [5]: http://maps.google.com
+ [6]: http://mail.google.com
+ [7]: http://docs.google.com
+ [8]: http://developer.mozilla.org
+
+Sachez que certains sites Web peut rediriger automatiquement depuis leur page d'accueil à une autre url, par exemple en utilisant le protocole https ou à un domaine de chaque pays. Par exemple, http://www.google.com redirigera pour utiliser SSL/TLS à https://www.google.com et puis peut également rediriger vers une géographie comme https://www.google.co.uk. Ces scénarios peuvent nécessiter des entrées de liste blanche modifiées ou supplémentaires au-delà de votre condition initiale. Pensez ce que vous construisez votre liste blanche.
+
+Notez que la liste d'autorisation s'applique uniquement à la principale webview Cordova et ne s'applique pas à une webview InAppBrowser ou l'ouverture des liens dans le navigateur web de système.
+
+## Amazon Fire OS liste blanche
+
+Règles spécifiques à la plateforme whitelisting se trouvent dans`res/xml/config.xml`.
+
+## Android liste blanche
+
+Comme ci-dessus, voir [cordova-plugin-whitelist][1] pour plus de détails. Pour cordova-android avant 4.0.0, voir les anciennes versions de cette documentation.
+
+## iOS liste blanche
+
+Comme ci-dessus, voir [cordova-plugin-whitelist][1] pour plus de détails. Cordova-iOS avant 4.0.0, voir les anciennes versions de cette documentation.
+
+## BlackBerry 10 liste blanche
+
+Les règles de liste blanche se trouvent dans `www/config.xml`.
+
+Utilisation de quelques dizaines de blackBerry de caractères génériques se distingue des autres plates-formes de deux façons :
+
+*   Tout contenu accédé par `XMLHttpRequest` doit être déclarée explicitement. Réglage `origin="*"` ne fonctionne pas dans ce cas. Sinon, tous sécurité web peut être désactivée à l'aide de la préférence `WebSecurity` décrite dans Configuration de BlackBerry :
+    
+        <preference name="websecurity" value="disable" />
+        
+
+*   Comme alternative au paramètre `*.domain`, définir un attribut supplémentaire `subdomains` `true`. Il devrait être la valeur `false` par défaut. Par exemple, le texte suivant permet d'accéder à `google.com`, `maps.google.com` et `docs.google.com` :
+    
+        <access origin="http://google.com" subdomains="true" />
+        
+    
+    L'accès de passage suivant vers `google.com` :
+    
+        <access origin="http://google.com" subdomains="false" />
+        
+    
+    Spécifier l'accès à tous les domaines, y compris le protocole local `file://` :
+    
+        <access origin="*" subdomains="true" />
+        
+
+(Pour plus d'informations sur la prise en charge, consultez documentation de BlackBerry sur l' [élément access][9].)
+
+ [9]: https://developer.blackberry.com/html5/documentation/ww_developing/Access_element_834677_11.html
+
+## Firefox OS
+
+Dans Firefox OS il n'y a aucun concept de liste blanche un domaine spécifique. Au lieu de cela, il y a une autorisation spéciale appelée [SystemXHR][10]. Il est nécessaire d'ajouter cette autorisation à `config.xml` :
+
+ [10]: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#Permissions
+
+    <platform name="firefoxos">
+        <permission name="systemXHR" privileged="true" description="load data from server" />
+    </platform>
+    
+
+L'objet `XMLHttpRequest` doit être instancié avec deux paramètres `mozAnon` et `mozSystem` :
+
+    var request = new XMLHttpRequest({
+        mozAnon: true,
+        mozSystem: true});
+    
+
+Cette solution est transparente, donc il n'y a pas de différence pour d'autres plateformes.
+
+## Windows Phone liste blanche
+
+Les règles de liste blanche pour Windows Phone 8 se trouvent dans le fichier `config.xml` du PPA.
+
+## Liste blanche paciarelli
+
+Règles de liste blanche sont trouvent dans le fichier `config.xml` du PPA. La plate-forme repose sur le même attribut de `subdomains` comme la plateforme BlackBerry. (Pour plus d'informations sur la prise en charge, consultez documentation de paciarelli sur l' [élément access][11].)
+
+ [11]: https://developer.tizen.org/help/index.jsp?topic=%2Forg.tizen.web.appprogramming%2Fhtml%2Fide_sdk_tools%2Fconfig_editor_w3celements.htm
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/fd1b79a4/www/docs/fr/5.4.0/guide/cli/index.md
----------------------------------------------------------------------
diff --git a/www/docs/fr/5.4.0/guide/cli/index.md b/www/docs/fr/5.4.0/guide/cli/index.md
new file mode 100644
index 0000000..caa4268
--- /dev/null
+++ b/www/docs/fr/5.4.0/guide/cli/index.md
@@ -0,0 +1,418 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: L'Interface en ligne de commande
+---
+
+# L'Interface en ligne de commande
+
+Ce guide a pour but de vous montrer comment créer des applications et les déployer sur différentes plates-formes mobiles natives à l'aide de l'Interface en Ligne de Commande (CLI) `cordova`. Cet outil vous permet de créer de nouveaux projets, les construire sur différentes plates-formes et exécuter sur des appareils réels ou au sein d'émulateurs. La CLI est le principal outil à utiliser pour le multi-plateforme de workflow décrit dans la vue d'ensemble. Dans le cas contraire, vous pouvez également utiliser la CLI pour initialiser le code du projet, puis basculez vers SDK et des outils de coquille pour la poursuite du développement des différentes plates-formes.
+
+## Prérequis
+
+Avant d'exécuter tout outil en ligne de commande, vous devez installer le SDK correspondant à chaque plate-forme ciblée. (Voir les Guides des Plates-formes pour plus de détails.)
+
+Afin d'ajouter le support ou de recompiler un projet pour n'importe quelle plate-forme, vous devez exécuter l'interface en ligne de commande depuis la même machine prenant en charge le SDK de la plate-forme concernée. La CLI supporte les combinaisons suivantes :
+
+*   iOS (Mac)
+*   Amazon Fire OS (Mac, Linux, Windows)
+*   Android (Mac, Linux, Windows)
+*   BlackBerry 10 (Mac, Linux, Windows)
+*   Windows Phone 8 (Windows)
+*   Windows (Windows)
+*   Firefox OS (Mac, Linux, Windows)
+
+Sous Mac, la ligne de commande est accessible via l'application *Terminal*. Sur PC, celle-ci est disponible via l'*invite de commande* sous *accessoires*.
+
+**NOTE**: pour les plates-formes Windows uniquement, vous pouvez toujours faire votre développement sur matériel Mac en exécutant Windows dans un environnement de machine virtuelle ou en mode dual-boot. Pour les options disponibles, consultez le Guide de plate-forme Windows Phone 8 ou Windows Platform.
+
+Plus il est probable que vous exécutez le CLI de machines différentes, plus il est logique de maintenir un référentiel de code source éloignée, dont les actifs vous tirez vers le bas pour les répertoires de travail local.
+
+## Installation de la CLI de Cordova
+
+L'outil de ligne de commande de Cordova est distribué comme un paquet de npm dans un format prêt à l'emploi. Il n'est pas nécessaire de compiler depuis les sources.
+
+Pour installer le `cordova` de ligne de commande outil, procédez comme suit :
+
+1.  Télécharger et installer [Node.js][1]. Après installation, vous devriez être capable d'appeler `node` et `npm` sur votre ligne de commande. Si vous le souhaitez, vous pouvez éventuellement utiliser un outil tel que `nvm` ou `nave` pour gérer votre installation de Node.js.
+
+2.  Téléchargez et installez un [client git][2], si vous n'avez pas déjà un. Après installation, vous devriez être en mesure d'invoquer `git` sur votre ligne de commande. Même si vous n'utilisez pas `git` manuellement, la CLI l'utilise dans les coulisses pour télécharger certains actifs lorsque vous créez un nouveau projet.
+
+3.  Installer le `cordova` à l'aide du module `npm` utilitaire de Node.js. Le `cordova` module sera automatiquement téléchargée par le `npm` utilitaire.
+
+ [1]: http://nodejs.org/
+ [2]: http://git-scm.com/
+
+*   sur OS X et Linux :
+    
+            $ sudo npm install -g cordova
+        
+    
+    Sur OS X et Linux, faisant précéder la `npm` commande avec `sudo` peut être nécessaire d'installer cette évolution utilitaire dans autrement limité répertoires tels que `/usr/local/share` . Si vous utilisez l'outil optionnel nvm/nef ou avez accès en écriture sur le répertoire d'installation, vous pourrez omettre la `sudo` préfixe. Il y a [plus de conseils][3] sur l'utilisation `npm` sans `sudo` , si vous désirez le faire.
+
+*   sur Windows :
+    
+            C:\>npm install -g cordova
+        
+    
+    Le `-g` option ci-dessus indique `npm` pour installer `cordova` dans le monde. Dans le cas contraire il sera installé dans le `node_modules` sous-répertoire du répertoire de travail courant.
+    
+    Vous devrez peut-être ajouter le `npm` répertoire à votre `PATH` pour BENEFICIER installés dans le monde `npm` modules. Sous Windows, `npm` peut habituellement être trouvé à `C:\Users\username\AppData\Roaming\npm` . Sur OS X et Linux, il peut généralement être trouvé à`/usr/local/share/npm`.
+    
+    Le journal d'installation peut générer des erreurs pour n'importe quelle plateforme désinstallé SDK.
+    
+    Après installation, vous devriez être en mesure d'exécuter `cordova` sur la ligne de commande avec aucun argument et il doit imprimer le texte d'aide.
+
+ [3]: http://justjs.com/posts/npm-link-developing-your-own-npm-modules-without-tears
+
+## Créer l'application
+
+Allez dans le répertoire où vous conservez votre code source et exécutez une commande comme suit :
+
+        $ cordova create hello com.example.hello HelloWorld
+    
+
+Il peut prendre un certain temps pour la commande pour terminer, alors soyez patient. L'exécution de la commande avec le `-d` option affiche des informations sur ses progrès.
+
+Le premier argument *Bonjour* spécifie un répertoire à générer pour votre projet. Ce répertoire ne devrait pas déjà exister, Cordova il créera pour vous. Sa `www` sous-répertoire maisons page d'accueil de votre application, ainsi que diverses ressources sous `css` , `js` , et `img` , qui suivent les conventions de dénomination de fichier du développement des web commun. Ces actifs seront stockées sur le système de fichiers local de l'appareil, n'a ne pas servi à distance. Le `config.xml` fichier contient des métadonnées importantes nécessaires pour générer et distribuer l'application.
+
+Le deuxième argument `com.example.hello` met à votre projet avec un identificateur de domaine inverse-style. Cet argument est facultatif, mais seulement si vous omettez également le troisième argument, puisque les arguments sont positionnels. Vous pouvez modifier cette valeur par la suite dans le `config.xml` du fichier, mais sachez qu'il peut y avoir de code généré en dehors de `config.xml` à l'aide de cette valeur, comme les noms de package Java. La valeur par défaut est `io.cordova.hellocordova` , mais il est recommandé que vous sélectionnez une valeur appropriée.
+
+Le troisième argument `HelloWorld` fournit le titre d'affichage de l'application. Cet argument est facultatif. Vous pouvez modifier cette valeur par la suite dans le `config.xml` du fichier, mais sachez qu'il peut y avoir de code généré en dehors de `config.xml` à l'aide de cette valeur, tels que les noms de classes Java. La valeur par défaut est `HelloCordova` , mais il est recommandé que vous sélectionnez une valeur appropriée.
+
+## Ajouter des plates-formes
+
+Toutes les commandes suivantes doivent être exécutées dans le répertoire du projet ou les sous-répertoires dans sa portée :
+
+        $ cd hello
+    
+
+Avant que vous pouvez générer le projet, vous devez spécifier un jeu de plates-formes cibles. Votre capacité d'exécuter ces commandes dépend de savoir si votre ordinateur prend en charge chaque SDK, et si vous avez déjà installé chaque SDK. Courir à chacun d'entre eux d'un Mac :
+
+        $ cordova platform add ios
+        $ cordova platform add amazon-fireos
+        $ cordova platform add android
+        $ cordova platform add blackberry10
+        $ cordova platform add firefoxos
+    
+
+Courir à chacun d'entre eux depuis une machine Windows, où *wp* se réfère aux différentes versions du système d'exploitation Windows Phone :
+
+        plate-forme cordova $ ajouter wp8 $ cordova plate-forme ajouter windows plate-forme cordova $ ajouter amazon-fireos plateforme de cordova $ ajouter $ android plate-forme cordova ajoutez blackberry10 $ cordova plate-forme ajouter firefoxos
+    
+
+Exécutez-le pour vérifier votre noyau de plateformes :
+
+        $ cordova platforms ls
+    
+
+(Note du `platform` et `platforms` commandes sont synonymes.)
+
+Exécutez une des commandes suivantes synonymes d'enlever une plate-forme :
+
+        $ cordova platform remove blackberry10
+        $ cordova platform rm amazon-fireos
+        $ cordova platform rm android
+    
+
+Exécution de commandes pour ajouter ou supprimer des affects de plates-formes le contenu du répertoire de *plates-formes* du projet, où chaque plate-forme spécifiée apparaît comme un sous-répertoire. Le répertoire de source *www* est reproduit dans le sous-répertoire de la plate-forme, qui apparaît par exemple dans `platforms/ios/www` ou `platforms/android/assets/www` . Parce que la CLI constamment des copies des fichiers du dossier source *www* , vous devez uniquement modifier ces fichiers et pas ceux situés dans les sous-répertoires de *plates-formes* . Si vous utilisez un logiciel de contrôle de version, vous devez ajouter ce dossier *www* source, ainsi que le dossier *se confond* , à votre système de contrôle de version. (On trouvera dans la section personnaliser chaque plate-forme ci-dessous plus d'informations sur le dossier *fusionne* .)
+
+**Avertissement**: lorsque vous utilisez l'interface CLI pour générer votre application, vous devriez modifier *n'est pas* tous les fichiers dans le `/platforms/` répertoire sauf si vous savez ce que vous faites, ou si la documentation spécifie autrement. Les fichiers dans ce répertoire sont systématiquement remplacés lors de la préparation des demandes de construction, ou lorsque les plugins sont réinstallés.
+
+Si vous le souhaitez à ce stade, vous pouvez utiliser un SDK comme Eclipse ou Xcode pour ouvrir le projet que vous avez créé. Vous devez ouvrir l'ensemble dérivé de l'actif de la `/platforms/` Répertoire de développer avec un SDK. C'est parce que les fichiers de métadonnées spécifiques de SDK sont stockés dans le cas échéant `/platform/` sous-répertoire. (Voir les [Guides de la plate-forme](../platforms/index.html) pour plus d'informations sur la façon de développer des applications au sein de chaque IDE.) Utilisez cette approche si vous souhaitez simplement initialiser un projet à l'aide de la CLI, puis passer à un SDK pour le travail indigène.
+
+Lire sur si vous souhaitez utiliser l'approche de flux de travail multi-plateforme (CLI) pour le cycle de développement complet.
+
+## Construire l'application
+
+Par défaut, le `cordova create` script génère une squelettique application web dont la page d'accueil est du projet `www/index.html` fichier. Modifier cette application, mais vous voulez, mais toute initialisation doit être spécifiée dans le cadre de la `[deviceready](../../cordova/events/events.deviceready.html)` gestionnaire d'événements, référencé par défaut de`www/js/index.js`.
+
+Exécutez la commande suivante pour générer itérativement le projet :
+
+        $ cordova build
+    
+
+Cela génère un code spécifique à la plateforme au sein du projet `platforms` sous-répertoire. Vous pouvez éventuellement restreindre la portée de chaque génération de plates-formes spécifiques :
+
+        $ cordova build ios
+    
+
+Le `cordova build` commande est un raccourci pour la suivante, qui, dans cet exemple, est également visé à une plate-forme unique :
+
+        $ cordova prepare ios
+        $ cordova compile ios
+    
+
+Dans ce cas, une fois que vous exécutez `prepare` , vous pouvez utiliser Apple Xcode SDK comme alternative pour modifier et compiler le code spécifique à la plateforme qui génère de Cordova dans `platforms/ios` . Vous pouvez utiliser la même approche avec les kits de développement logiciel des autres plates-formes.
+
+## Tester l'application sur un émulateur ou un périphérique
+
+Kits de développement logiciel pour les plates-formes mobiles sont souvent livrés avec les émulateurs qui exécutent un élément image, afin que vous pouvez lancer l'application depuis l'écran d'accueil et voir comment il interagit avec de nombreuses fonctionnalités de la plate-forme. Exécuter une commande telle que la suivante pour reconstruire l'app et il découvre au sein de l'émulateur une spécifique de la plate-forme :
+
+        $ cordova emulate android
+    
+
+Certaines plates-formes mobiles émulent un périphérique par défaut, tels que l'iPhone pour les projets de l'iOS. Pour d'autres plateformes, vous devrez tout d'abord associer un périphérique avec un émulateur.
+
+**NOTE**: support d'émulateur n'est actuellement pas disponible pour Amazon Fire OS.
+
+(Voir les [Guides de la plate-forme](../platforms/index.html) pour plus de détails.) Par exemple, vous pouvez d'abord exécuter la `android` commande pour lancer le SDK Android, puis exécutez une image de périphérique particulier, dont il lance selon son comportement par défaut :
+
+![][4]
+
+ [4]: {{ site.baseurl }}/static/img/guide/cli/android_emulate_init.png
+
+Suivi auprès du `cordova emulate` commande actualise l'image de l'émulateur pour afficher la dernière application, qui est maintenant disponible pour le lancement de l'écran d'accueil :
+
+![][5]
+
+ [5]: {{ site.baseurl }}/static/img/guide/cli/android_emulate_install.png
+
+Alternativement, vous pouvez brancher le combiné dans votre ordinateur et tester l'application directement :
+
+        $ cordova run android
+    
+
+Avant d'exécuter cette commande, vous devez mettre en place le dispositif de test, suivant des procédures qui varient pour chaque plate-forme. Dans les appareils Android et OS feu Amazon, vous devrez activer une option de **Débogage USB** sur l'appareil et peut-être ajouter un pilote USB selon votre environnement de développement. Consultez les [Guides de la plate-forme](../platforms/index.html) pour plus de détails sur les exigences de chaque plateforme.
+
+## Ajouter des fonctionnalités du Plugin
+
+Lorsque vous générez et découvre un nouveau projet, l'application par défaut qui s'affiche ne fait pas grand chose. Vous pouvez modifier l'application de plusieurs façons de tirer parti des technologies web standard, mais l'application de communiquer étroitement avec diverses fonctions au niveau du périphérique, vous devez ajouter des plugins qui permettent d'accéder au noyau Cordova APIs.
+
+Un *plugin* est un peu de code complémentaire qui fournit une interface pour les composants natifs. Vous pouvez concevoir votre propre interface plugin, par exemple, lorsque vous concevez une application hybride qui mêle une Cordova WebView composants natifs. (Voir intégration WebViews et [Plugin Development Guide][6] pour plus de détails). Habituellement, vous devez ajouter un plugin pour permettre à l'une des caractéristiques de niveau périphérique base de Cordova, détaillées dans la référence de l'API.
+
+ [6]: guide_hybrid_plugins_index.md.html#Plugin%20Development%20Guide
+
+Depuis la version 3.0, lorsque vous créez un projet de Cordova il n'a pas les plug-ins présents. C'est le nouveau comportement par défaut. Les plug-ins que vous désirez, même les plugins de base, doivent être ajoutés explicitement.
+
+On trouvera une liste de ces plugins, y compris les plugins tiers supplémentaires fournies par la Communauté, dans le registre à [plugins.cordova.io][7]. Vous pouvez utiliser l'interface CLI à la recherche de plugins de ce registre. Par exemple, la recherche de `bar` et `code` produit un résultat unique qui correspond à ces deux termes comme des sous-chaînes insensible à la casse :
+
+ [7]: http://plugins.cordova.io/
+
+        $ cordova plugin search bar code
+    
+        com.phonegap.plugins.barcodescanner - Scans Barcodes
+    
+
+Vous cherchez seulement le `bar` à terme les rendements et résultats supplémentaires :
+
+        cordova-plugin-statusbar - Cordova StatusBar Plugin
+    
+
+Le `cordova plugin add` commande nécessite vous permet de spécifier le référentiel pour le code du plugin. Voici des exemples d'utilisation de l'interface CLI pour ajouter des fonctionnalités à l'application :
+
+*   Informations de base périphérique (Device API) :
+    
+        $ cordova plugin add cordova-plugin-device
+        
+
+*   Connexion réseau et événements de la batterie :
+    
+        $ cordova plugin add cordova-plugin-network-information
+        $ cordova plugin add cordova-plugin-battery-status
+        
+
+*   Accéléromètre, boussole et géolocalisation :
+    
+        $ cordova plugin add cordova-plugin-device-motion
+        $ cordova plugin add cordova-plugin-device-orientation
+        $ cordova plugin add cordova-plugin-geolocation
+        
+
+*   Appareil photo, lecture et Capture :
+    
+        $ cordova plugin add cordova-plugin-camera
+        $ cordova plugin add cordova-plugin-media-capture
+        $ cordova plugin add cordova-plugin-media
+        
+
+*   Accéder aux fichiers sur un périphérique réseau (fichier API) :
+    
+        $ cordova plugin add cordova-plugin-file
+        $ cordova plugin add cordova-plugin-file-transfer
+        
+
+*   Notification via la boîte de dialogue ou de vibration :
+    
+        $ cordova plugin add cordova-plugin-dialogs
+        $ cordova plugin add cordova-plugin-vibration
+        
+
+*   Contacts :
+    
+        $ cordova plugin add cordova-plugin-contacts
+        
+
+*   Mondialisation :
+    
+        $ cordova plugin add cordova-plugin-globalization
+        
+
+*   SplashScreen :
+    
+        $ cordova plugin add cordova-plugin-splashscreen
+        
+
+*   Fenêtres ouvertes du navigateur nouvelle (InAppBrowser) :
+    
+        $ cordova plugin add cordova-plugin-inappbrowser
+        
+
+*   Console de débogage :
+    
+        $ cordova plugin add cordova-plugin-console
+        
+
+**NOTE**: le CLI ajoute le code du plugin comme il convient pour chaque plate-forme. Si vous souhaitez développer avec les outils de bas niveau coque ou plate-forme SDK tel que discuté dans l'aperçu, vous devez exécuter l'utilitaire Plugman pour ajouter des plugins séparément pour chaque plate-forme. (Pour plus d'informations, voir Plugman à l'aide à gérer les Plugins).
+
+Utilisation `plugin ls` (ou `plugin list` , ou `plugin` en soi) à Découvre actuellement les plugins installés. Chacun affiche par son identificateur :
+
+        $ cordova plugin ls    # or 'plugin list'
+        [ 'cordova-plugin-console' ]
+    
+
+Pour supprimer un plugin, faire référence à elle par le même identificateur qui apparaît dans la liste. Par exemple, voici comment vous enlèverait le soutien pour une console de débogage d'une version :
+
+        $ cordova plugin rm cordova-plugin-console
+        $ cordova plugin remove cordova-plugin-console    # same
+    
+
+Vous pouvez lot-supprimer ou ajouter des plugins en spécifiant plusieurs arguments pour chaque commande :
+
+        $ cordova plugin add cordova-plugin-console cordova-plugin-device
+    
+
+## Options du Plugin avancé
+
+Lors de l'ajout d'un plugin, plusieurs options vous permettent de spécifier où aller chercher le plugin. Les exemples ci-dessus utilisent un célèbre `registry.cordova.io` Registre, ainsi que le plugin est spécifiée par la `id` :
+
+        $ cordova plugin add cordova-plugin-console
+    
+
+Le `id` peut également inclure le numéro de version du plugin, reproduite après un `@` caractère. La `latest` version est un alias pour la version la plus récente. Par exemple :
+
+        $ cordova plugin add cordova-plugin-console@latest
+        $ cordova plugin add cordova-plugin-console@0.2.1
+    
+
+Si le plugin n'est pas inscrite au `registry.cordova.io` mais se trouve dans un autre dépôt git, vous pouvez spécifier une URL de substitution :
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git
+    
+
+L'exemple de git ci-dessus récupère le plugin depuis la fin de la branche master, mais un autre git-Réf tel une balise ou une branche peut être ajoutée après un `#` caractère :
+
+Installer à partir d'une balise :
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#r0.2.0
+    
+
+ou une succursale :
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#CB-8438cordova-plugin-console
+    
+
+ou git-Réf pourrait également être une validation particulière :
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#f055daec45575bf08538f885e09c85a0eba363ff
+    
+
+Si le plugin (et son fichier `plugin.xml` ) sont dans un sous-répertoire dans le repo git, vous pouvez le spécifier avec un caractère `:` . Notez que le caractère `#` est toujours nécessaire :
+
+        $ cordova plugin add https://github.com/someone/aplugin.git#:/my/sub/dir
+    
+
+Vous pouvez également combiner le git-Réf tant le sous-répertoire :
+
+        $ cordova plugin add https://github.com/someone/aplugin.git#r0.0.1:/my/sub/dir
+    
+
+Vous pouvez également spécifier un chemin d'accès local vers le répertoire de plugin qui contient le fichier `plugin.xml` :
+
+        $ cordova plugin add ../my_plugin_dir
+    
+
+## À l'aide de *fusionne* pour personnaliser chaque plate-forme
+
+Alors que Cordoue vous permet de déployer facilement une application pour de nombreuses plateformes différentes, parfois vous avez besoin d'ajouter des personnalisations. Dans ce cas, vous ne voulez pas modifier les fichiers source dans divers répertoires `www` dans le répertoire de niveau supérieur de `platforms` , parce qu'ils sont régulièrement remplacés par source multi-plateforme du répertoire niveau supérieur `www` .
+
+Au lieu de cela, le répertoire de niveau supérieur `merges` offre un endroit pour spécifier des actifs de déployer sur des plates-formes spécifiques. Chaque sous-répertoire `merges`, correspondant à une plate-forme donnée, reflète la structure du répertoire source `www`, ce qui vous permet de surcharger ou ajouter des fichiers au besoin. Par exemple, voici comment vous pourriez utilisations `merges` pour augmenter la taille de police par défaut pour les appareils Android et Amazon Fire OS :
+
+*   Modifier la `www/index.html` fichier, en ajoutant un lien vers un fichier CSS supplémentaire, `overrides.css` dans ce cas :
+    
+        <link rel="stylesheet" type="text/css" href="css/overrides.css" />
+        
+
+*   Créer éventuellement un vide `www/css/overrides.css` fichier, qui s'applique pour toutes les versions non-Android, empêchant une erreur de fichier manquant.
+
+*   Créer un `css` sous-répertoire dans `merges/android` , puis ajoutez un correspondant `overrides.css` fichier. Spécifier CSS qui remplace la taille de police de 12 points par défaut spécifiée dans `www/css/index.css` , par exemple :
+    
+        body { font-size:14px; }
+        
+
+Lorsque vous régénérez le projet, la version Android dispose de la taille de police personnalisée, tandis que d'autres restent inchangés.
+
+Vous pouvez également utiliser `merges` pour ajouter des fichiers non présents dans le répertoire original de `www` . Par exemple, une application peut intégrer un *bouton* graphique à l'interface d'iOS, stocké dans `merges/ios/img/back_button.png`, tandis que la version Android peut au lieu de capter `ButtonBack` événements depuis le bouton matériel correspondant.
+
+## Aide commandes
+
+Cordoue possède quelques commandes globales, qui peuvent vous aider si vous êtes coincé ou rencontrez un problème. La commande `help` affiche toutes les commandes disponibles de Cordova et leur syntaxe :
+
+    $ cordova help
+    $ cordova        # same
+    
+
+En outre, vous pouvez obtenir une aide plus détaillée sur une commande spécifique. Par exemple :
+
+    $ cordova run --help
+    
+
+La commande `infos` produit une liste des informations potentiellement utiles, tels que les plates-formes actuellement installés et plugins, des versions pour chaque plate-forme SDK et versions de la CLI et `node.js`:
+
+    $ cordova info
+    
+
+Celle-ci présente l'information à l'écran et capture la sortie dans un fichier local `info.txt` .
+
+**NOTE**: actuellement, seuls les détails sur iOS et Android plates-formes sont disponibles.
+
+## Mise à jour de Cordova et votre projet
+
+Après l'installation de l'utilitaire de `cordova` , vous pouvez toujours mettre à jour vers la dernière version en exécutant la commande suivante :
+
+        $ sudo npm update -g cordova
+    
+
+Utilisez cette syntaxe pour installer une version spécifique :
+
+        $ sudo npm install -g cordova@3.1.0-0.2.0
+    
+
+Exécutez `cordova -v` pour voir quelle version est en cours d'exécution. Exécutez la commande `npm info` pour obtenir une liste plus longue qui inclut la version actuelle ainsi que d'autres numéros de version disponible :
+
+        $ npm info cordova
+    
+
+Cordova 3.0 est la première version à supporter l'interface de ligne de commande décrite dans cette section. Si vous mettez à jour depuis une version antérieure à 3.0, vous devez créer un nouveau projet, tel que décrit ci-dessus, puis copiez les actifs les plus âgés de l'application dans le répertoire de niveau supérieur `www` . Le cas échéant, plus amples détails au sujet de la mise à niveau vers 3.0 sont disponibles dans les [Guides de la plate-forme](../platforms/index.html). Une fois que vous passer à l'interface de ligne de commande de `cordova` et utilisez `mise à jour de la NGP` se pour tenir au courant, les plus longues procédures décrits là ne sont plus pertinentes.
+
+Cordova 3.0 + peut-être encore exiger des divers changements à la structure de répertoire au niveau du projet et les autres dépendances. Après avoir exécuté la commande `NGP` ci-dessus pour mettre à jour de Cordoue elle-même, vous devrez peut-être s'assurer que les ressources de votre projet sont conformes aux exigences de la version la plus récente. Exécutez une commande semblable à la suivante pour chaque plate-forme que vous générez :
+
+        $ cordova platform update android
+        $ cordova platform update ios
+        ...etc.


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org


Mime
View raw message