You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by ld...@apache.org on 2014/08/01 22:23:44 UTC
[3/3] git commit: CB-7249cordova-plugin-file documentation
translation: cordova-plugin-file
CB-7249cordova-plugin-file documentation translation: cordova-plugin-file
Project: http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/repo
Commit: http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/commit/fa64fa54
Tree: http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/tree/fa64fa54
Diff: http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/diff/fa64fa54
Branch: refs/heads/master
Commit: fa64fa54ca953e45c10f559659833eadf34b48b8
Parents: 8913257
Author: Lisa Seacat DeLuca <ld...@us.ibm.com>
Authored: Fri Aug 1 16:23:36 2014 -0400
Committer: Lisa Seacat DeLuca <ld...@us.ibm.com>
Committed: Fri Aug 1 16:23:36 2014 -0400
----------------------------------------------------------------------
doc/de/index.md | 158 +++++++++++++++++++++++++++++++-------------
doc/es/index.md | 158 +++++++++++++++++++++++++++++++-------------
doc/fr/index.md | 158 +++++++++++++++++++++++++++++++-------------
doc/it/index.md | 158 +++++++++++++++++++++++++++++++-------------
doc/ja/index.md | 158 +++++++++++++++++++++++++++++++-------------
doc/ko/index.md | 158 +++++++++++++++++++++++++++++++-------------
doc/pl/index.md | 182 ++++++++++++++++++++++++++++++++++++---------------
doc/ru/index.md | 158 +++++++++++++++++++++++++++++++-------------
doc/zh/index.md | 168 ++++++++++++++++++++++++++++++++---------------
9 files changed, 1021 insertions(+), 435 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/fa64fa54/doc/de/index.md
----------------------------------------------------------------------
diff --git a/doc/de/index.md b/doc/de/index.md
index e7c21f7..84153b4 100644
--- a/doc/de/index.md
+++ b/doc/de/index.md
@@ -56,27 +56,87 @@ Finden Sie einen Überblick über andere Speicheroptionen Cordovas [Speicher-Fü
Stand: V1 werden URLs auf wichtige Datei-System-Verzeichnisse zur Verfügung gestellt. Jede URL in der Form *file:///path/to/spot/*ist, und konvertiert werden können eine `DirectoryEntry` mit`window.resolveLocalFileSystemURL()`.
-`cordova.file.applicationDirectory`-Die schreibgeschützten Verzeichnis, in dem die Anwendung installiert ist. (*iOS*, *Android*)
+* `cordova.file.applicationDirectory`-Die schreibgeschützten Verzeichnis, in dem die Anwendung installiert ist. (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.applicationStorageDirectory`-Stamm der app's private beschreibbaren Speicher. (*iOS*, *Android*)
+* `cordova.file.applicationStorageDirectory`-Root-Verzeichnis der Anwendungs-Sandbox; auf iOS ist schreibgeschützt (aber bestimmte Unterverzeichnisse [wie `/Documents` ] sind Lese-und Schreibzugriff). Alle enthaltene Daten ist für die app privat. ( *iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.dataDirectory`-Wo app-spezifische Datendateien zu setzen. (*iOS*, *Android*)
+* `cordova.file.dataDirectory`-Beständige und private Datenspeicherung innerhalb der Anwendungs-Sandbox, die mit internen Speicher (auf Android, externen Speicher verwenden, verwenden Sie `.externalDataDirectory` ). Auf iOS, ist dieses Verzeichnis nicht mit iCloud synchronisiert (verwenden Sie `.syncedDataDirectory` ). (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.cacheDirectory`-Cache-Dateien, die app startet überleben sollte. Apps sollten nicht vom Betriebssystem zum Löschen von Dateien hier verlassen. (*iOS*, *Android*)
+* `cordova.file.cacheDirectory`-Verzeichnis der zwischengespeicherten Daten-Dateien oder Dateien, die Ihre app einfach neu erstellen können. Das Betriebssystem kann diese Dateien löschen, wenn das Gerät auf Speicher knapp wird, dennoch sollten die apps vom Betriebssystem zum Löschen von Dateien hier nicht verlassen. (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.externalApplicationStorageDirectory`-Anwendungsraum auf externen Speicher. (*iOS*, *Android*)
+* `cordova.file.externalApplicationStorageDirectory`-Anwendungsraum auf externen Speicher. (*Android*)
-`cordova.file.externalDataDirectory`-Wo, app-spezifische Datendateien auf externen Speicher setzen. (*Android*)
+* `cordova.file.externalDataDirectory`-Wo, app-spezifische Datendateien auf externen Speicher setzen. (*Android*)
-`cordova.file.externalCacheDirectory`-Anwendungscache auf externen Speicher. (*Android*)
+* `cordova.file.externalCacheDirectory`-Anwendungscache auf externen Speicher. (*Android*)
-`cordova.file.externalRootDirectory`-Externer Speicher (SD-Karte) Stamm. (*Android*)
+* `cordova.file.externalRootDirectory`-Externer Speicher (SD-Karte) Stamm. (*Android*, *BlackBerry 10*)
-`cordova.file.tempDirectory`-Temp-Verzeichnis, dem das OS auf deaktivieren können wird. (*iOS*)
+* `cordova.file.tempDirectory`-Temp-Verzeichnis, dem das OS auf deaktivieren können wird. Verlassen Sie sich nicht auf das Betriebssystem, um dieses Verzeichnis zu löschen; Ihre Anwendung sollte immer Dateien gegebenenfalls entfernen. (*iOS*)
-`cordova.file.syncedDataDirectory`-Hält app-spezifische Dateien, die (z. B. auf iCloud) synchronisiert werden sollten. (*iOS*)
+* `cordova.file.syncedDataDirectory`-Hält app-spezifische Dateien, die (z. B. auf iCloud) synchronisiert werden sollten. (*iOS*)
-`cordova.file.documentsDirectory`-Dateien für die app, aber privat sind sinnvoll, andere Anwendungen (z.B. Office-Dateien). (*iOS*)
+* `cordova.file.documentsDirectory`-Dateien für die app, aber privat sind sinnvoll, andere Anwendungen (z.B. Office-Dateien). (*iOS*)
+
+* `cordova.file.sharedDirectory`-Dateien für alle Anwendungen (*BlackBerry 10* weltweit verfügbar)
+
+## Dateisystemlayouts
+
+Obwohl technisch ein Implementierungsdetail, kann es sehr hilfreich zu wissen wie die `cordova.file.*` Eigenschaften anzeigen auf physischen Pfade auf einem echten Gerät.
+
+### iOS-Datei-System-Layout
+
+| Gerätepfad | `Cordova.file.*` | `iosExtraFileSystems` | R/w? | persistent? | OS löscht | Sync | Private |
+|:-------------------------------------------- |:--------------------------- |:--------------------- |:----:|:-----------:|:----------:|:----:|:-------:|
+| `/ Var/mobile/Applications/< UUID > /` | applicationStorageDirectory | - | R/o | N/A | N/A | N/A | Ja |
+| `appname.app/` | applicationDirectory | Bundle | R/o | N/A | N/A | N/A | Ja |
+| `www/` | - | - | R/o | N/A | N/A | N/A | Ja |
+| `Documents/` | documentsDirectory | Dokumente | R/w | Ja | Nein | Ja | Ja |
+| `NoCloud/` | - | Dokumente-nosync | R/w | Ja | Nein | Nein | Ja |
+| `Library` | - | Bibliothek | R/w | Ja | Nein | Ja? | Ja |
+| `NoCloud/` | dataDirectory | Bibliothek-nosync | R/w | Ja | Nein | Nein | Ja |
+| `Cloud/` | syncedDataDirectory | - | R/w | Ja | Nein | Ja | Ja |
+| `Caches/` | cacheDirectory | Cache | R/w | Ja * | Ja \* * *| | Nein | Ja |
+| `tmp/` | tempDirectory | - | R/w | Nicht * * | Ja \* * *| | Nein | Ja |
+
+* Dateien werden hinweg app Neustarts und Upgrades beibehalten, aber dieses Verzeichnis kann gelöscht werden, wenn das OS begehrt. Ihre Anwendung sollte in der Lage, Inhalte zu erschaffen, die möglicherweise gelöscht werden.
+
+* *-Dateien kann über app-Neustarts beizubehalten, aber verlasse dich nicht auf dieses Verhalten. Dateien sind nicht unbedingt Aktuelles beibehalten. Ihre Anwendung sollte Dateien aus diesem Verzeichnis entfernen, wenn es gilt, diese Dateien werden entfernt, da das OS nicht wann (oder auch wenn) garantiert.
+
+\* * *| The OS kann den Inhalt dieses Verzeichnisses löschen, wenn es sich anfühlt, ist es erforderlich, aber verlassen Sie sich nicht dazu. Sie sollten dieses Verzeichnis entsprechend Ihrer Anwendung deaktivieren.
+
+### Android File System-Layout
+
+| Gerätepfad | `Cordova.file.*` | `AndroidExtraFileSystems` | R/w? | persistent? | OS löscht | Private |
+|:--------------------------------- |:----------------------------------- |:------------------------- |:----:|:-----------:|:---------:|:-------:|
+| `file:///android_asset/` | applicationDirectory | | R/o | N/A | N/A | Ja |
+| `/ Data/Data/< app-Id > /` | applicationStorageDirectory | - | R/w | N/A | N/A | Ja |
+| `cache` | cacheDirectory | Cache | R/w | Ja | Ja * | Ja |
+| `files` | dataDirectory | Dateien | R/w | Ja | Nein | Ja |
+| `Documents` | | Dokumente | R/w | Ja | Nein | Ja |
+| `< Sdcard > /` | externalRootDirectory | sdcard | R/w | Ja | Nein | Nein |
+| `Android/data/<app-id>/` | externalApplicationStorageDirectory | - | R/w | Ja | Nein | Nein |
+| `cache` | externalCacheDirectry | Cache-extern | R/w | Ja | Nicht * * | Nein |
+| `files` | externalDataDirectory | Dateien-extern | R/w | Ja | Nein | Nein |
+
+* Das Betriebssystem kann regelmäßig dieses Verzeichnis zu löschen, aber verlasse dich nicht auf dieses Verhalten. Deaktivieren Sie den Inhalt dieses Verzeichnisses für Ihre Anwendung geeigneten. Ein Benutzer den Cache manuell löschen sollte, werden die Inhalte dieses Verzeichnisses entfernt.
+
+* * The OS nicht klar dieses Verzeichnis automatisch; Sie sind verantwortlich für die Inhalte selbst verwalten. Der Benutzer den Cache manuell löschen sollte, werden der Inhalt des Verzeichnisses entfernt.
+
+**Hinweis**: Wenn externe Speichergeräte nicht bereitgestellt werden kann, die `cordova.file.external*` Eigenschaften sind`null`.
+
+### BlackBerry 10-File-System-Layout
+
+| Gerätepfad | `Cordova.file.*` | R/w? | persistent? | OS löscht | Private |
+|:--------------------------------------------------- |:--------------------------- |:----:|:-----------:|:---------:|:-------:|
+| `file:///Accounts/1000/APPDATA/ < app Id > /` | applicationStorageDirectory | R/o | N/A | N/A | Ja |
+| `app/native` | applicationDirectory | R/o | N/A | N/A | Ja |
+| `data/webviews/webfs/temporary/local__0` | cacheDirectory | R/w | Nein | Ja | Ja |
+| `data/webviews/webfs/persistent/local__0` | dataDirectory | R/w | Ja | Nein | Ja |
+| `file:///Accounts/1000/Removable/sdcard` | externalRemovableDirectory | R/w | Ja | Nein | Nein |
+| `file:///Accounts/1000/Shared` | sharedDirectory | R/w | Ja | Nein | Nein |
+
+*Hinweis*: Wenn die Anwendung bereitgestellt wird, um Perimeter zu arbeiten, alle Pfade sind relativ /accounts/1000-enterprise.
## Android Macken
@@ -88,23 +148,24 @@ Es gibt mehrere gültige Speicherorte, persistente Dateien auf einem Android-Ger
Frühere Versionen des Plugins wählen würde, den Speicherort der temporären und permanenten Dateien beim Start, basierend auf, ob das Gerät behauptete, dass die SD-Karte (oder gleichwertige Speicherpartition) bereitgestellt wurde. Wenn die SD-Karte eingelegt wurde, oder wenn eine große interne Speicherpartition verfügbar war (wie auf Nexus-Geräten) und dann in die Wurzel dieses Raumes, die persistenten Dateien gespeichert werden. Dies bedeutete, dass alle Cordova apps aller verfügbaren Dateien auf der Karte sehen konnte.
-Wenn die SD-Karte nicht verfügbar war, würde dann frühere Versionen unter/Data/Data/Datenspeicher<packageid>, die apps von einander isoliert, kann aber noch Daten für Benutzer freigegeben werden.
+Wenn die SD-Karte nicht verfügbar war, dann Vorgängerversionen Daten unter speichern würde `/data/data/<packageId>` , die isoliert Anwendungen voneinander, aber möglicherweise noch Ursache Daten zwischen Benutzern freigegeben werden.
-Es ist jetzt möglich, ob Sie Dateien der internen Datei-Speicherort oder unter Verwendung der bisherigen Logik, mit einer Präferenz in der Anwendung-config.xml-Datei speichern möchten. Hierzu fügen Sie eine dieser zwei Zeilen zu "config.xml":
+Es ist nun möglich, auszuwählen, ob zum Speichern von Dateien in den internen Datei-Speicherort oder unter Verwendung der bisherigen Logik mit einer Vorliebe in Ihrer Anwendung `config.xml` Datei. Hierzu fügen Sie eines dieser beiden Linien zu `config.xml` :
<preference name="AndroidPersistentFileLocation" value="Internal" />
<preference name="AndroidPersistentFileLocation" value="Compatibility" />
-Ohne diese Zeile wird die Datei-Erweiterung "Kompatibilität" als Standard verwenden. Wenn ein Präferenz-Tag vorhanden ist, und nicht einen der folgenden Werte, wird die Anwendung nicht gestartet.
+Ohne diese Zeile das Datei-Plugin verwendet `Compatibility` als Standard. Wenn ein Präferenz-Tag vorhanden ist, und nicht einen der folgenden Werte, wird die Anwendung nicht gestartet.
-Wenn Ihre Anwendung für Benutzer zuvor versandt wird, mithilfe eines älteren (Pre-1.0) Version dieses Plugins und gespeicherte Dateien im permanenten Dateisystem hat, dann setzen Sie die Einstellung auf "Kompatibilität". Wechseln die Location auf "Internal" würde bedeuten, dass Benutzer, die aktualisieren Sie ihre Anwendung, möglicherweise nicht auf ihre zuvor gespeicherte Dateien, abhängig von ihrem Gerät zugreifen.
+Wenn Ihre Anwendung für Benutzer zuvor versandt wird, mithilfe eines älteren (Pre-1.0) Version dieses Plugins und gespeicherte Dateien im permanenten Dateisystem hat, dann legen Sie die Voreinstellung "" auf `Compatibility` . Wechseln die Location auf "Internal" würde bedeuten, dass Benutzer, die aktualisieren Sie ihre Anwendung, möglicherweise nicht auf ihre zuvor gespeicherte Dateien, abhängig von ihrem Gerät zugreifen.
-Wenn Ihre Anwendung neu ist, oder nie zuvor Dateien im Dateisystem persistent gespeichert hat, wird die "interne" Einstellung im Allgemeinen empfohlen.
+Wenn die Anwendung neu, oder nie zuvor, Dateien im Dateisystem persistent gespeichert hat, dann die `Internal` Einstellung wird im Allgemeinen empfohlen.
## iOS Macken
+* `cordova.file.applicationStorageDirectory`ist schreibgeschützt; zum Speichern von Dateien im Stammverzeichnis der Versuch schlägt fehl. Verwenden Sie eine der anderen `cordova.file.*` für iOS definierten Eigenschaften (nur `applicationDirectory` und `applicationStorageDirectory` sind schreibgeschützt).
* `FileReader.readAsText(blob, encoding)`
* Die `encoding` Parameter wird nicht unterstützt und UTF-8-Kodierung ist immer wirksam.
@@ -112,28 +173,29 @@ Wenn Ihre Anwendung neu ist, oder nie zuvor Dateien im Dateisystem persistent ge
Es gibt zwei gültige Speicherorte persistente Dateien auf ein iOS-Gerät speichern: das Dokumenten-Verzeichnis und das Verzeichnis Library. Frühere Versionen des Plugins gespeichert immer nur persistente Dateien im Verzeichnis Dokumente. Dies hatte den Nebeneffekt einer Anwendung Dateien in iTunes, die oft unbeabsichtigte, speziell für Anwendungen, die viele kleine Dateien behandeln war, sichtbar zu machen, anstatt komplette Dokumente für den Export, die den beabsichtigten Zweck des Verzeichnisses ist zu produzieren.
-Es ist jetzt möglich, ob Sie Dateien in Dokumente oder Verzeichnis Library mit einer Präferenz in der Anwendung-config.xml-Datei speichern möchten. Hierzu fügen Sie eine dieser zwei Zeilen zu "config.xml":
+Es ist nun möglich, auszuwählen, ob zum Speichern von Dateien in Dokumente oder Verzeichnis Library mit einer Vorliebe in Ihrer Anwendung `config.xml` Datei. Hierzu fügen Sie eines dieser beiden Linien zu `config.xml` :
<preference name="iosPersistentFileLocation" value="Library" />
<preference name="iosPersistentFileLocation" value="Compatibility" />
-Ohne diese Zeile wird die Datei-Erweiterung "Kompatibilität" als Standard verwenden. Wenn ein Präferenz-Tag vorhanden ist, und nicht einen der folgenden Werte, wird die Anwendung nicht gestartet.
+Ohne diese Zeile das Datei-Plugin verwendet `Compatibility` als Standard. Wenn ein Präferenz-Tag vorhanden ist, und nicht einen der folgenden Werte, wird die Anwendung nicht gestartet.
-Wenn Ihre Anwendung für Benutzer zuvor versandt wird, mithilfe eines älteren (Pre-1.0) Version dieses Plugins und gespeicherte Dateien im permanenten Dateisystem hat, dann setzen Sie die Einstellung auf "Kompatibilität". Wechseln zu "Library" Position würde bedeuten, dass Benutzer, die ihre Anwendung aktualisieren nicht in der Lage wäre, ihre zuvor gespeicherte Dateien zugreifen.
+Wenn Ihre Anwendung für Benutzer zuvor versandt wird, mithilfe eines älteren (Pre-1.0) Version dieses Plugins und gespeicherte Dateien im permanenten Dateisystem hat, dann legen Sie die Voreinstellung "" auf `Compatibility` . Wechsel der Lage zu `Library` würde bedeuten, dass Benutzer, aktualisieren Sie ihre Anwendung, nicht in der Lage, ihre zuvor gespeicherte Dateien zugreifen.
-Wenn die Anwendung neu, oder nie zuvor Dateien im Dateisystem persistent gespeichert hat, wird die Einstellung "Bibliothek" empfohlen.
+Wenn die Anwendung neu, oder nie zuvor, Dateien im Dateisystem persistent gespeichert hat, dann die `Library` Einstellung wird im Allgemeinen empfohlen.
-### Firefox OS Macken
+## Firefox OS Macken
Der Datei-System-API wird von Firefox-OS nicht nativ unterstützt und wird als ein Shim auf IndexedDB implementiert.
* Schlägt nicht fehl, wenn Sie nicht leere Verzeichnisse entfernen
* Metadaten wird für Verzeichnisse nicht unterstützt.
-* Bietet keine Unterstützung für `requestAllFileSystems` und `resolveLocalFileSystemURI` Methoden
* Methoden `copyTo` und `moveTo` unterstützen keine Verzeichnisse
+Die folgenden Datenpfade werden unterstützt: * `applicationDirectory` -verwendet `xhr` um lokale Dateien zu erhalten, die mit der app verpackt sind. * `dataDirectory` - Für persistente app-spezifische Daten-Dateien. * `cacheDirectory` -Cache-Dateien, die app startet überleben sollte (Apps sollten nicht vom Betriebssystem zum Löschen von Dateien hier verlassen).
+
## Upgrade Notes
In v1.0.0 des Plugins die `FileEntry` und `DirectoryEntry` Strukturen haben sich geändert, um mehr im Einklang mit der veröffentlichten Spezifikation zu sein.
@@ -153,7 +215,7 @@ Mit v1.0.0 das `fullPath` -Attribut ist der Pfad zu der Datei, *relativ zum Stam
Wenn Ihre Anwendung mit absoluter Gerätepfade arbeitet und Sie zuvor diese Pfade durch abgerufenen die `fullPath` -Eigenschaft des `Entry` Objekte, dann Sie Ihren Code mithilfe von update sollte `entry.toURL()` statt.
-Für rückwärts Kompatibilität, die `resolveLocalFileSystemURL()` -Methode akzeptiert einen Absolute-Gerätepfad und kehren ein `Entry` -Objekt entspricht, solange diese Datei innerhalb von vorübergehenden oder dauerhaften Dateisysteme existiert.
+Für rückwärts Kompatibilität, die `resolveLocalFileSystemURL()` -Methode akzeptiert einen Absolute-Gerätepfad und kehren ein `Entry` Objekt entspricht, solange diese Datei innerhalb existiert der `TEMPORARY` oder `PERSISTENT` Dateisysteme.
Dies wurde vor allem ein Problem mit dem File-Transfer-Plugin, die zuvor-Absolute-Gerätepfade verwendet (und kann damit noch einverstanden). Es wurde aktualisiert, um ordnungsgemäß mit Dateisystem-URLs, so anstelle `entry.fullPath` mit `entry.toURL()` sollte lösen Sie alle Probleme, die immer des Plugin zum Arbeiten mit Dateien auf dem Gerät.
@@ -168,18 +230,20 @@ die benutzt werden können, um die Datei eindeutig zu identifizieren.
Wenn ein Fehler ausgelöst wird, wird eines der folgenden Codes verwendet werden.
-* 1 = NOT\_FOUND\_ERR
-* 2 = SECURITY_ERR
-* 3 = ABORT_ERR
-* 4 = NOT\_READABLE\_ERR
-* 5 = ENCODING_ERR
-* 6 = NO\_MODIFICATION\_ALLOWED_ERR
-* 7 = INVALID\_STATE\_ERR
-* 8 = SYNTAX_ERR
-* 9 = INVALID\_MODIFICATION\_ERR
-* 10 = QUOTA\_EXCEEDED\_ERR
-* 11 = TYPE\_MISMATCH\_ERR
-* 12 = PATH\_EXISTS\_ERR
+| Code | Konstante |
+| ----:|:----------------------------- |
+| 1 | `NOT_FOUND_ERR` |
+| 2 | `SECURITY_ERR` |
+| 3 | `ABORT_ERR` |
+| 4 | `NOT_READABLE_ERR` |
+| 5 | `ENCODING_ERR` |
+| 6 | `NO_MODIFICATION_ALLOWED_ERR` |
+| 7 | `INVALID_STATE_ERR` |
+| 8 | `SYNTAX_ERR` |
+| 9 | `INVALID_MODIFICATION_ERR` |
+| 10 | `QUOTA_EXCEEDED_ERR` |
+| 11 | `TYPE_MISMATCH_ERR` |
+| 12 | `PATH_EXISTS_ERR` |
## Konfigurieren das Plugin (Optional)
@@ -191,21 +255,21 @@ Die Menge der verfügbaren Dateisysteme kann pro Plattform konfiguriert sein. Er
### Android
-* Dateien: interne Datei-Speicher-Verzeichnis der Anwendung
-* Dateien-extern: Verzeichnis der Anwendung externe Datei Speicher
-* Sdcard: das externe Globaldatei-Speicherverzeichnis (Dies ist die Wurzel der SD-Karte, sofern installiert). Sie müssen die `android.permission.WRITE_EXTERNAL_STORAGE` Erlaubnis, diese zu verwenden.
-* Cache: internen Cache-Verzeichnis der Anwendung
-* Cache-extern: externer Cache-Verzeichnis der Anwendung
-* Wurzel: das gesamte Gerät-Dateisystem
+* `files`: Die Anwendung interner Speicher Dateiverzeichnis
+* `files-external`: Das Verzeichnis der Anwendung externe Datei Speicher
+* `sdcard`: Das externe Globaldatei-Speicherverzeichnis (Dies ist die Wurzel der SD-Karte, sofern installiert). Sie müssen die `android.permission.WRITE_EXTERNAL_STORAGE` Erlaubnis, diese zu verwenden.
+* `cache`: Internen Cache-Verzeichnis der Anwendung
+* `cache-external`: Die Anwendung externer Cache-Verzeichnis
+* `root`: Das gesamte Gerät-Dateisystem
Android unterstützt auch eine spezielle Dateisystem mit dem Namen "Dokumente", die ein Unterverzeichnis "/ Dokumente /" die "Dateien" Dateisystem darstellt.
### iOS
-* Bibliothek: Bibliothek-Verzeichnis der Anwendung
-* Dokumente: Dokumente-Verzeichnis der Anwendung
-* Cache: Cache-Verzeichnis der Anwendung
-* Bundle: die Anwendung Bündel; den Speicherort der die app selbst auf dem Datenträger (schreibgeschützt)
-* Wurzel: das gesamte Gerät-Dateisystem
+* `library`: Bibliothek das Anwendungsverzeichnis
+* `documents`: Dokumente das Anwendungsverzeichnis
+* `cache`: Cache-Verzeichnis der Anwendung
+* `bundle`: Die Anwendung Bündel; den Speicherort der die app selbst auf dem Datenträger (schreibgeschützt)
+* `root`: Das gesamte Gerät-Dateisystem
-Standardmäßig können die Bibliothek und Dokumenten-Verzeichnisse mit iCloud synchronisiert werden. Sie können auch beantragen, zwei zusätzliche Dateisysteme, "Bibliothek-Nosync" und "Dokumente-Nosync", die einem speziellen nicht synchronisierten Verzeichnis im Dateisystem Bibliothek oder Dokumente darstellen.
\ No newline at end of file
+Standardmäßig können die Bibliothek und Dokumenten-Verzeichnisse mit iCloud synchronisiert werden. Können Sie auch beantragen, zwei zusätzliche Dateisysteme, `library-nosync` und `documents-nosync` , die repräsentieren eine spezielle nicht synchronisierten Verzeichnis innerhalb der `/Library` oder `/Documents` Dateisystem.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/fa64fa54/doc/es/index.md
----------------------------------------------------------------------
diff --git a/doc/es/index.md b/doc/es/index.md
index 7dd2edd..eb5e689 100644
--- a/doc/es/index.md
+++ b/doc/es/index.md
@@ -56,27 +56,87 @@ Para tener una visión general de otras opciones de almacenamiento, consulte [Gu
A partir de v1.2.0, URLs a directorios de sistema de archivos importantes son proporcionadas. Cada dirección URL está en la forma *file:///path/to/spot/*y se puede convertir en un `DirectoryEntry` usando`window.resolveLocalFileSystemURL()`.
-`cordova.file.applicationDirectory`-Directorio Read-only donde está instalada la aplicación. (*iOS*, *Android*)
+* `cordova.file.applicationDirectory`-Directorio Read-only donde está instalada la aplicación. (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.applicationStorageDirectory`-Raíz de almacenamiento escribible privado de app. (*iOS*, *Android*)
+* `cordova.file.applicationStorageDirectory`-Directorio del entorno limitado de la aplicación; en iOS esta ubicación es de sólo lectura (pero subdirectorios específicos [como `/Documents` ] son de lectura y escritura). Todos los datos contenidos dentro es privado para la aplicación. ( *iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.dataDirectory`¿Dónde poner los archivos de datos específicos de la aplicación. (*iOS*, *Android*)
+* `cordova.file.dataDirectory`-Almacenamiento de datos persistente y privadas dentro de entorno limitado de la aplicación utilizando la memoria interna (en Android, si necesitas usar memoria externa, use `.externalDataDirectory` ). En iOS, este directorio no está sincronizado con iCloud (utilice `.syncedDataDirectory` ). (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.cacheDirectory`-Almacena en caché los archivos que deben sobrevivir se reinicia la aplicación. Aplicaciones no deben confiar en el sistema operativo para eliminar los archivos de aquí. (*iOS*, *Android*)
+* `cordova.file.cacheDirectory`-Directorio para los archivos de datos almacenados en caché o los archivos que su aplicación puede volver a crear fácilmente. El sistema operativo puede borrar estos archivos cuando el dispositivo se agota en almacenamiento de información, sin embargo, aplicaciones no deben confiar en el sistema operativo para eliminar los archivos de aquí. (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.externalApplicationStorageDirectory`-Espacio aplicación de almacenamiento externo. (*iOS*, *Android*)
+* `cordova.file.externalApplicationStorageDirectory`-Espacio aplicación de almacenamiento externo. (*Android*)
-`cordova.file.externalDataDirectory`¿Dónde poner los archivos de datos específicos de la aplicación de almacenamiento externo. (*Android*)
+* `cordova.file.externalDataDirectory`¿Dónde poner los archivos de datos específicos de la aplicación de almacenamiento externo. (*Android*)
-`cordova.file.externalCacheDirectory`-Caché aplicación de almacenamiento externo. (*Android*)
+* `cordova.file.externalCacheDirectory`-Caché aplicación de almacenamiento externo. (*Android*)
-`cordova.file.externalRootDirectory`-Raíz de almacenamiento externo (tarjeta SD). (*Android*)
+* `cordova.file.externalRootDirectory`-Raíz de almacenamiento externo (tarjeta SD). (*Android*, *BlackBerry 10*)
-`cordova.file.tempDirectory`-Directorio temporal que puede borrar el sistema operativo en sí. (*iOS*)
+* `cordova.file.tempDirectory`-Directorio temporal que puede borrar el sistema operativo en sí. No confíe en el sistema operativo para borrar este directorio; su aplicación siempre debe eliminar archivos según corresponda. (*iOS*)
-`cordova.file.syncedDataDirectory`-Contiene los archivos de la aplicación específica que deben ser sincronizados (e.g. a iCloud). (*iOS*)
+* `cordova.file.syncedDataDirectory`-Contiene los archivos de la aplicación específica que deben ser sincronizados (e.g. a iCloud). (*iOS*)
-`cordova.file.documentsDirectory`-Archivos privados a la aplicación, pero que son significativos para otros applciations (por ejemplo archivos de Office). (*iOS*)
+* `cordova.file.documentsDirectory`-Archivos privados a la aplicación, pero que son significativos para otra aplicación (por ejemplo archivos de Office). (*iOS*)
+
+* `cordova.file.sharedDirectory`-Archivos disponibles globalmente para todas las aplicaciones (*BlackBerry 10*)
+
+## Diseños de sistema de archivo
+
+Aunque técnicamente un detalle de la implementación, puede ser muy útil saber cómo la `cordova.file.*` mapa de propiedades en trazados físicos en un dispositivo real.
+
+### iOS diseño de sistema de archivo
+
+| Ruta de dispositivo | `Cordova.file.*` | `iosExtraFileSystems` | ¿r/w? | ¿persistente? | OS despeja | sincronización | privado |
+|:-------------------------------------------- |:--------------------------- |:--------------------- |:-----:|:-------------:|:----------:|:--------------:|:-------:|
+| `/ var/mobile/Applications/< UUID > /` | applicationStorageDirectory | - | r/o | N / A | N / A | N / A | Sí |
+| `appname.app/` | applicationDirectory | Bundle | r/o | N / A | N / A | N / A | Sí |
+| `www/` | - | - | r/o | N / A | N / A | N / A | Sí |
+| `Documents/` | documentsDirectory | documentos | r/w | Sí | No | Sí | Sí |
+| `NoCloud/` | - | documentos-nosync | r/w | Sí | No | No | Sí |
+| `Library` | - | Biblioteca | r/w | Sí | No | ¿Sí? | Sí |
+| `NoCloud/` | dataDirectory | Biblioteca-nosync | r/w | Sí | No | No | Sí |
+| `Cloud/` | syncedDataDirectory | - | r/w | Sí | No | Sí | Sí |
+| `Caches/` | cacheDirectory | caché | r/w | Sí * | Si \* * *| | No | Sí |
+| `tmp/` | tempDirectory | - | r/w | No * * | Si \* * *| | No | Sí |
+
+* Archivos persisten a través de la aplicación se reinicia y actualizaciones, pero este directorio puede ser despejó cuando el OS desea. Su aplicación debe ser capaz de recrear cualquier contenido que puede ser eliminado.
+
+* * Archivos pueden persistir a través de la aplicación se reinicia, pero no confiar en este comportamiento. Los archivos no se garantizan que persisten a través de actualizaciones. Su aplicación debe eliminar los archivos de este directorio cuando es aplicable, como el sistema operativo no garantiza cuando (o incluso si) estos archivos se quitan.
+
+\* * *| OS la puede borrar el contenido de este directorio cuando se siente que es necesario, pero no dependen de éste. Debe borrar este directorio según sea apropiado para su aplicación.
+
+### Disposición del sistema Android File
+
+| Ruta de dispositivo | `Cordova.file.*` | `AndroidExtraFileSystems` | ¿r/w? | ¿persistente? | OS despeja | privado |
+|:----------------------------------------- |:----------------------------------- |:------------------------- |:-----:|:-------------:|:----------:|:-------:|
+| `File:///android_asset/` | applicationDirectory | | r/o | N / A | N / A | Sí |
+| `/Data/data/< id de aplicación > /` | applicationStorageDirectory | - | r/w | N / A | N / A | Sí |
+| `cache` | cacheDirectory | caché | r/w | Sí | Sí * | Sí |
+| `files` | dataDirectory | archivos | r/w | Sí | No | Sí |
+| `Documents` | | documentos | r/w | Sí | No | Sí |
+| `< sdcard > /` | externalRootDirectory | sdcard | r/w | Sí | No | No |
+| `Android/data/<app-id>/` | externalApplicationStorageDirectory | - | r/w | Sí | No | No |
+| `cache` | externalCacheDirectry | caché-externo | r/w | Sí | No * * | No |
+| `files` | externalDataDirectory | archivos externos | r/w | Sí | No | No |
+
+* El sistema operativo puede eliminar periódicamente este directorio, pero no dependen de este comportamiento. Borrar el contenido de este directorio según sea apropiado para su aplicación. El contenido de este directorio debe un usuario purga la caché manualmente, se eliminan.
+
+* * El sistema operativo no borra este directorio automáticamente; Usted es responsable de administrar el contenido mismo. Deberá el usuario purga la caché manualmente, se extraen los contenidos del directorio.
+
+**Nota**: Si no se puede montar de almacenamiento externo, el `cordova.file.external*` Propiedades`null`.
+
+### Disposición del sistema blackBerry 10 archivo
+
+| Ruta de dispositivo | `Cordova.file.*` | ¿r/w? | ¿persistente? | OS despeja | privado |
+|:------------------------------------------------------------- |:--------------------------- |:-----:|:-------------:|:----------:|:-------:|
+| `File:///accounts/1000/AppData/ < id de aplicación > /` | applicationStorageDirectory | r/o | N / A | N / A | Sí |
+| `app/native` | applicationDirectory | r/o | N / A | N / A | Sí |
+| `data/webviews/webfs/temporary/local__0` | cacheDirectory | r/w | No | Sí | Sí |
+| `data/webviews/webfs/persistent/local__0` | dataDirectory | r/w | Sí | No | Sí |
+| `File:///accounts/1000/Removable/sdcard` | externalRemovableDirectory | r/w | Sí | No | No |
+| `File:///accounts/1000/shared` | sharedDirectory | r/w | Sí | No | No |
+
+*Nota*: cuando se implementa la aplicación al trabajo de perímetro, todos los caminos son relativos a /accounts/1000-enterprise.
## Rarezas Android
@@ -88,23 +148,24 @@ Hay múltiples ubicaciones válidas para almacenar archivos persistentes en un d
Las versiones anteriores del plugin elegiría la ubicación de los archivos temporales y persistentes en el arranque, basado en si el dispositivo afirmó que fue montado en la tarjeta SD (o partición de almacenamiento equivalente). Si fue montada en la tarjeta SD, o una partición de gran almacenamiento interno estaba disponible (como en dispositivos de Nexus,) y luego los archivos persistentes se almacenaría en la raíz de ese espacio. Esto significaba que todas las apps Cordova podían ver todos los archivos disponibles en la tarjeta.
-Si la tarjeta SD no estaba disponible, entonces las versiones anteriores almacenará datos bajo /data/data /<packageid>, que aísla las apps del otro, pero todavía puede causar datos ser compartido entre los usuarios.
+Si la tarjeta SD no estaba disponible, entonces versiones anteriores podría almacenar datos debajo de `/data/data/<packageId>` , que aísla las apps del otro, pero puede todavía causa datos para ser compartido entre los usuarios.
-Ahora es posible elegir si desea almacenar archivos en la ubicación de almacenamiento del archivo interno, o usando la lógica anterior, con preferencia en el archivo config.xml de su aplicación. Para ello, añada una de estas dos líneas en config.xml:
+Ahora es posible elegir si desea almacenar archivos en la ubicación de almacenamiento del archivo interno, o usando la lógica anterior, con una preferencia en de la aplicación `config.xml` archivo. Para ello, añada una de estas dos líneas a `config.xml` :
<preference name="AndroidPersistentFileLocation" value="Internal" />
<preference name="AndroidPersistentFileLocation" value="Compatibility" />
-Sin esta línea, el archivo plugin utilizará "Compatibilidad" como el valor por defecto. Si una etiqueta de preferencia está presente y no es uno de estos valores, no se iniciará la aplicación.
+Sin esta línea, se utilizará el archivo plugin `Compatibility` como valor predeterminado. Si una etiqueta de preferencia está presente y no es uno de estos valores, no se iniciará la aplicación.
-Si su solicitud se ha enviado previamente a los usuarios, mediante una mayor (1.0 pre) versión de este plugin y archivos almacenados en el sistema de ficheros persistente, entonces se debe establecer la preferencia a la "Compatibilidad". Cambiar la ubicación para "Internal" significa que los usuarios existentes que actualización su aplicación pueden ser incapaces de acceder a sus archivos previamente almacenadas, dependiendo de su dispositivo.
+Si su solicitud se ha enviado previamente a los usuarios, mediante una mayor (1.0 pre) versión de este plugin y archivos almacenados en el sistema de ficheros persistente, entonces debería establecer la preferencia en `Compatibility` . Cambiar la ubicación para "Internal" significa que los usuarios existentes que actualización su aplicación pueden ser incapaces de acceder a sus archivos previamente almacenadas, dependiendo de su dispositivo.
-Si su solicitud es nueva, o nunca antes ha almacenado archivos en el sistema de ficheros persistente, el ajuste "interno" se recomienda generalmente.
+Si su solicitud es nuevo, o nunca antes ha almacenado archivos en el sistema de ficheros persistente, entonces el `Internal` generalmente se recomienda el ajuste.
## iOS rarezas
+* `cordova.file.applicationStorageDirectory`es de sólo lectura; intentar almacenar archivos en el directorio raíz fallará. Utilice uno de los `cordova.file.*` las propiedades definidas para iOS (sólo `applicationDirectory` y `applicationStorageDirectory` son de sólo lectura).
* `FileReader.readAsText(blob, encoding)`
* El `encoding` no se admite el parámetro, y codificación UTF-8 es siempre en efecto.
@@ -112,28 +173,29 @@ Si su solicitud es nueva, o nunca antes ha almacenado archivos en el sistema de
Hay dos ubicaciones válidas para almacenar archivos persistentes en un dispositivo iOS: el directorio de documentos y el directorio de biblioteca. Las versiones anteriores del plugin sólo almacenan archivos persistentes en el directorio de documentos. Esto tenía el efecto secundario de todos los archivos de la aplicación haciendo visible en iTunes, que era a menudo involuntarios, especialmente para aplicaciones que manejan gran cantidad de archivos pequeños, en lugar de producir documentos completos para la exportación, que es la finalidad del directorio.
-Ahora es posible elegir si desea almacenar archivos en los documentos o directorio de bibliotecas, con preferencia en el archivo config.xml de su aplicación. Para ello, añada una de estas dos líneas en config.xml:
+Ahora es posible elegir si desea almacenar archivos en los documentos o directorio de bibliotecas, con preferencia en de la aplicación `config.xml` archivo. Para ello, añada una de estas dos líneas a `config.xml` :
<preference name="iosPersistentFileLocation" value="Library" />
<preference name="iosPersistentFileLocation" value="Compatibility" />
-Sin esta línea, el archivo plugin utilizará "Compatibilidad" como el valor por defecto. Si una etiqueta de preferencia está presente y no es uno de estos valores, no se iniciará la aplicación.
+Sin esta línea, se utilizará el archivo plugin `Compatibility` como valor predeterminado. Si una etiqueta de preferencia está presente y no es uno de estos valores, no se iniciará la aplicación.
-Si su solicitud se ha enviado previamente a los usuarios, mediante una mayor (1.0 pre) versión de este plugin y archivos almacenados en el sistema de ficheros persistente, entonces se debe establecer la preferencia a la "Compatibilidad". Cambiar la ubicación a la "Biblioteca" significa que los usuarios existentes que actualización su aplicación sería incapaces de acceder a sus archivos previamente almacenadas.
+Si su solicitud se ha enviado previamente a los usuarios, mediante una mayor (1.0 pre) versión de este plugin y archivos almacenados en el sistema de ficheros persistente, entonces debería establecer la preferencia en `Compatibility` . Cambiar la ubicación de `Library` significa que los usuarios existentes que actualización su aplicación sería incapaces de acceder a sus archivos previamente almacenadas.
-Si su solicitud es nueva, o nunca antes ha almacenado archivos en el sistema de ficheros persistente, el ajuste de "Biblioteca" generalmente se recomienda.
+Si su solicitud es nuevo, o nunca antes ha almacenado archivos en el sistema de ficheros persistente, entonces el `Library` generalmente se recomienda el ajuste.
-### Firefox OS rarezas
+## Firefox OS rarezas
La API de sistema de archivo de forma nativa no es compatible con Firefox OS y se implementa como una cuña en la parte superior indexedDB.
* No falla cuando eliminar directorios no vacía
* No admite metadatos para directorios
-* No es compatible con `requestAllFileSystems` y `resolveLocalFileSystemURI` métodos
* Los métodos `copyTo` y `moveTo` no son compatibles con directorios
+Se admiten las siguientes rutas de datos: * `applicationDirectory` -usa `xhr` para obtener los archivos locales que están envasados con la aplicación. * `dataDirectory` - Para archivos de datos específicos de aplicación persistente. * `cacheDirectory` -En caché archivos que deben sobrevivir se reinicia la aplicación (aplicaciones no deben confiar en el sistema operativo para eliminar archivos aquí).
+
## Actualización de notas
En v1.0.0 de este plugin, la `FileEntry` y `DirectoryEntry` han cambiado las estructuras, para estar más acorde con las especificaciones publicadas.
@@ -153,7 +215,7 @@ Con v1.0.0, la `fullPath` es la ruta del archivo, *relativo a la raíz del siste
Si su aplicación funciona con dispositivo-absoluto-caminos, y previamente obtenido esos caminos a través de la `fullPath` propiedad de `Entry` objetos, entonces debe actualizar su código para utilizar `entry.toURL()` en su lugar.
-Para atrás compatibilidad, el `resolveLocalFileSystemURL()` método aceptará un dispositivo-absoluto-trayectoria y volverá un `Entry` objeto correspondiente, mientras exista ese archivo dentro de los sistemas de ficheros temporales o permanentes.
+Para atrás compatibilidad, el `resolveLocalFileSystemURL()` método aceptará un dispositivo-absoluto-trayectoria y volverá un `Entry` objeto correspondiente, mientras exista ese archivo dentro o el `TEMPORARY` o `PERSISTENT` filesystems.
Esto ha sido particularmente un problema con el plugin de transferencia de archivos, que anteriormente utilizado dispositivo-absoluto-caminos (y todavía puede aceptarlas). Se ha actualizado para que funcione correctamente con las URLs de FileSystem, reemplazando así `entry.fullPath` con `entry.toURL()` debe resolver cualquier problema conseguir ese plugin para trabajar con archivos en el dispositivo.
@@ -168,18 +230,20 @@ que puede utilizarse para identificar el archivo únicamente.
Cuando se produce un error, uno de los siguientes códigos se utilizará.
-* 1 = NOT\_FOUND\_ERR
-* 2 = SECURITY_ERR
-* 3 = ABORT_ERR
-* 4 = NOT\_READABLE\_ERR
-* 5 = ENCODING_ERR
-* 6 = NO\_MODIFICATION\_ALLOWED_ERR
-* 7 = INVALID\_STATE\_ERR
-* 8 = SYNTAX_ERR
-* 9 = INVALID\_MODIFICATION\_ERR
-* 10 = QUOTA\_EXCEEDED\_ERR
-* 11 = TYPE\_MISMATCH\_ERR
-* 12 = PATH\_EXISTS\_ERR
+| Código | Constante |
+| ------:|:----------------------------- |
+| 1 | `NOT_FOUND_ERR` |
+| 2 | `SECURITY_ERR` |
+| 3 | `ABORT_ERR` |
+| 4 | `NOT_READABLE_ERR` |
+| 5 | `ENCODING_ERR` |
+| 6 | `NO_MODIFICATION_ALLOWED_ERR` |
+| 7 | `INVALID_STATE_ERR` |
+| 8 | `SYNTAX_ERR` |
+| 9 | `INVALID_MODIFICATION_ERR` |
+| 10 | `QUOTA_EXCEEDED_ERR` |
+| 11 | `TYPE_MISMATCH_ERR` |
+| 12 | `PATH_EXISTS_ERR` |
## Configurando el Plugin (opcional)
@@ -191,21 +255,21 @@ El conjunto de los sistemas de ficheros disponibles puede ser configurado por pl
### Android
-* archivos: directorio de almacenamiento de archivo interno de la aplicación
-* archivos externos: directorio de almacenamiento de archivo externo de la aplicación
-* sdcard: el directorio de almacenamiento de archivo externo global (esta es la raíz de la tarjeta SD, si uno está instalado). Debes tener el `android.permission.WRITE_EXTERNAL_STORAGE` permiso para usar esto.
-* memoria caché: directorio de memoria caché interna de la aplicación
-* caché-externo: directorio de caché externo de la aplicación
-* raíz: el sistema de archivos de todo el dispositivo
+* `files`: Directorio de almacenamiento de archivos internos de la aplicación
+* `files-external`: Directorio de almacenamiento del la aplicación archivo externo
+* `sdcard`: El directorio de almacenamiento de archivo externo global (esta es la raíz de la tarjeta SD, si uno está instalado). Debes tener el `android.permission.WRITE_EXTERNAL_STORAGE` permiso para usar esto.
+* `cache`: Directorio de la aplicación la memoria caché interna
+* `cache-external`: Directorio de caché externo de la aplicación
+* `root`: El sistema de archivos de todo el dispositivo
Android también es compatible con un sistema de archivos especial llamado "documentos", que representa un subdirectorio "/ documentos /" dentro del sistema de archivos "archivos".
### iOS
-* Biblioteca: directorio de bibliotecas de la aplicación
-* documentos: directorio de documentos de la aplicación
-* memoria caché: directorio de caché de la aplicación
-* paquete: paquete de la aplicación; la ubicación de la aplicación en sí mismo en el disco (sólo lectura)
-* raíz: el sistema de archivos de todo el dispositivo
+* `library`: Directorio de la aplicación la biblioteca
+* `documents`: Directorio de documentos de la solicitud
+* `cache`: Directorio de caché de la aplicación la
+* `bundle`: Paquete la aplicación; la ubicación de la aplicación en sí mismo en el disco (sólo lectura)
+* `root`: El sistema de archivos de todo el dispositivo
-De forma predeterminada, los directorios de documentos y la biblioteca pueden ser sincronizados con iCloud. También puede solicitar dos sistemas adicionales, "biblioteca-nosync" y "documentos-nosync", que representan un directorio no-sincronizado especial dentro del sistema de ficheros de biblioteca o documentos.
\ No newline at end of file
+De forma predeterminada, los directorios de documentos y la biblioteca pueden ser sincronizados con iCloud. También puede solicitar dos sistemas de archivos adicionales, `library-nosync` y `documents-nosync` , que representa un directorio especial no sincronizados dentro de la `/Library` o `/Documents` sistema de ficheros.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-plugin-file/blob/fa64fa54/doc/fr/index.md
----------------------------------------------------------------------
diff --git a/doc/fr/index.md b/doc/fr/index.md
index e7cce64..9549c7a 100644
--- a/doc/fr/index.md
+++ b/doc/fr/index.md
@@ -56,27 +56,87 @@ Pour un aperçu des autres options de stockage, consultez [guide d'entreposage d
À partir de v1.2.0, URL vers des répertoires de système de fichiers importants est fournis. Chaque URL est dans la forme *file:///path/to/spot/*et peut être converti en un `DirectoryEntry` à l'aide`window.resolveLocalFileSystemURL()`.
-`cordova.file.applicationDirectory`-Lecture seule répertoire où l'application est installée. (*iOS*, *Android*)
+* `cordova.file.applicationDirectory`-Lecture seule répertoire où l'application est installée. (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.applicationStorageDirectory`-Racine de stockage accessible en écriture privé de l'application. (*iOS*, *Android*)
+* `cordova.file.applicationStorageDirectory`-Répertoire racine du bac à sable de l'application ; cet endroit est en lecture seule sur iOS (mais les sous-répertoires spécifiques [comme `/Documents` ] sont en lecture / écriture). Toutes les données qu'il contient est privé de l'application. ( *iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.dataDirectory`-Où placer les fichiers de données d'application spécifiques. (*iOS*, *Android*)
+* `cordova.file.dataDirectory`-Stockage des données persistants et privés au sein de bac à sable de l'application à l'aide de la mémoire interne (sur Android, si vous avez besoin d'utiliser une mémoire externe, utilisez `.externalDataDirectory` ). Sur iOS, ce répertoire n'est pas synchronisé avec iCloud (utiliser `.syncedDataDirectory` ). (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.cacheDirectory`-Mise en cache de fichiers qui doivent survivre app redémarre. Apps ne doivent pas compter sur le système d'exploitation pour supprimer les fichiers ici. (*iOS*, *Android*)
+* `cordova.file.cacheDirectory`-Répertoire pour les fichiers de données en mémoire cache ou les fichiers que votre application peut recréer facilement. L'OS peut supprimer ces fichiers lorsque l'appareil faiblit sur stockage, néanmoins, les applications ne doivent pas compter sur l'OS pour supprimer les fichiers ici. (*iOS*, *Android*, *BlackBerry 10*)
-`cordova.file.externalApplicationStorageDirectory`-Espace l'application sur le stockage externe. (*iOS*, *Android*)
+* `cordova.file.externalApplicationStorageDirectory`-Espace l'application sur le stockage externe. (*Android*)
-`cordova.file.externalDataDirectory`-Où placer les fichiers de données d'application spécifiques sur le stockage externe. (*Android*)
+* `cordova.file.externalDataDirectory`-Où placer les fichiers de données d'application spécifiques sur le stockage externe. (*Android*)
-`cordova.file.externalCacheDirectory`-Cache de l'application sur le stockage externe. (*Android*)
+* `cordova.file.externalCacheDirectory`-Cache de l'application sur le stockage externe. (*Android*)
-`cordova.file.externalRootDirectory`-Racine de stockage externe (carte SD). (*Android*)
+* `cordova.file.externalRootDirectory`-Racine de stockage externe (carte SD). (*Android*, *BlackBerry 10*)
-`cordova.file.tempDirectory`-Répertoire temp que l'OS peut effacer à volonté. (*iOS*)
+* `cordova.file.tempDirectory`-Répertoire temp que l'OS peut effacer à volonté. Ne comptez pas sur l'OS pour effacer ce répertoire ; votre application doit toujours supprimer les fichiers selon le cas. (*iOS*)
-`cordova.file.syncedDataDirectory`-Contient des fichiers d'app spécifique qui doivent se synchroniser (par exemple à iCloud). (*iOS*)
+* `cordova.file.syncedDataDirectory`-Contient des fichiers d'app spécifique qui doivent se synchroniser (par exemple à iCloud). (*iOS*)
-`cordova.file.documentsDirectory`-Fichiers privés à l'app, mais qui sont utiles à d'autres applications (par exemple les fichiers Office). (*iOS*)
+* `cordova.file.documentsDirectory`-Fichiers privés à l'app, mais qui sont significatives pour l'autre application (par exemple les fichiers Office). (*iOS*)
+
+* `cordova.file.sharedDirectory`-Fichiers disponibles globalement à toutes les applications (*BlackBerry 10*)
+
+## Structures de système de fichiers
+
+Bien que techniquement un détail d'implémentation, il peut être très utile de savoir comment les `cordova.file.*` carte de propriétés à des chemins d'accès physiques sur un périphérique réel.
+
+### iOS agencement de système de fichier
+
+| Chemin de l'unité | `Cordova.file.*` | `iosExtraFileSystems` | r/w ? | persistants ? | OS efface | Sync | privé |
+|:-------------------------------------------- |:--------------------------- |:--------------------- |:-----:|:-------------:|:-----------:|:-----:|:-----:|
+| `/ var/mobile/Applications/< UUID > /` | applicationStorageDirectory | - | r/o | N/A | N/A | N/A | Oui |
+| `appname.app/` | applicationDirectory | Bundle | r/o | N/A | N/A | N/A | Oui |
+| `www/` | - | - | r/o | N/A | N/A | N/A | Oui |
+| `Documents/` | documentsDirectory | documents | r/w | Oui | Non | Oui | Oui |
+| `NoCloud/` | - | documents-nosync | r/w | Oui | Non | Non | Oui |
+| `Library` | - | Bibliothèque | r/w | Oui | Non | Oui ? | Oui |
+| `NoCloud/` | dataDirectory | Bibliothèque-nosync | r/w | Oui | Non | Non | Oui |
+| `Cloud/` | syncedDataDirectory | - | r/w | Oui | Non | Oui | Oui |
+| `Caches/` | cacheDirectory | cache | r/w | Oui * | Oui \* * *| | Non | Oui |
+| `tmp/` | tempDirectory | - | r/w | Ne * * | Oui \* * *| | Non | Oui |
+
+* Fichiers persistent à travers les redémarrages de l'application et mises à niveau, mais ce répertoire peut être effacé à chaque fois que les désirs de l'OS. Votre application doit être en mesure de recréer tout contenu qui pourrait être supprimé.
+
+* * Fichiers peuvent persister redémarrages de l'application, mais ne vous fiez pas ce comportement. Les fichiers ne sont pas garantis à persister dans l'ensemble de mises à jour. Votre application doit supprimer les fichiers de ce répertoire lorsqu'elle s'applique, comme le système d'exploitation ne garantit pas quand (ou même si) ces fichiers sont supprimés.
+
+\* * *| L'OS peut effacer le contenu de ce répertoire chaque fois qu'il se sent il est nécessaire, mais ne comptez pas là-dessus. Vous devez supprimer ce répertoire comme approprié pour votre application.
+
+### Agencement de système de fichiers Android
+
+| Chemin de l'unité | `Cordova.file.*` | `AndroidExtraFileSystems` | r/w ? | persistants ? | OS efface | privé |
+|:----------------------------------- |:----------------------------------- |:------------------------- |:-----:|:-------------:|:---------:|:-----:|
+| `file:///android_asset/` | applicationDirectory | | r/o | N/A | N/A | Oui |
+| `/ données/data/app < id > /` | applicationStorageDirectory | - | r/w | N/A | N/A | Oui |
+| `cache` | cacheDirectory | cache | r/w | Oui | Oui * | Oui |
+| `files` | dataDirectory | fichiers | r/w | Oui | Non | Oui |
+| `Documents` | | documents | r/w | Oui | Non | Oui |
+| `< sdcard > /` | externalRootDirectory | sdcard | r/w | Oui | Non | Non |
+| `Android/data/<app-id>/` | externalApplicationStorageDirectory | - | r/w | Oui | Non | Non |
+| `cache` | externalCacheDirectry | cache-externe | r/w | Oui | Ne * * | Non |
+| `files` | externalDataDirectory | fichiers externes | r/w | Oui | Non | Non |
+
+* Le système d'exploitation peut effacer périodiquement ce répertoire, mais ne vous fiez pas ce comportement. Effacer le contenu de ce répertoire comme approprié pour votre application. Un utilisateur doit purger le cache manuellement, le contenu de ce répertoire est supprimé.
+
+* * The OS vous n'effacez pas ce répertoire automatiquement ; vous êtes chargé de gérer le contenu vous-même. L'utilisateur devrait purger le cache manuellement, le contenu du répertoire est supprimé.
+
+**Remarque**: si le stockage externe ne peut pas être monté, les `cordova.file.external*` sont des propriétés`null`.
+
+### Configuration du système blackBerry 10 fichier
+
+| Chemin de l'unité | `Cordova.file.*` | r/w ? | persistants ? | OS efface | privé |
+|:--------------------------------------------------- |:--------------------------- |:-----:|:-------------:|:---------:|:-----:|
+| `file:///Accounts/1000/AppData/ < id app > /` | applicationStorageDirectory | r/o | N/A | N/A | Oui |
+| `app/native` | applicationDirectory | r/o | N/A | N/A | Oui |
+| `data/webviews/webfs/temporary/local__0` | cacheDirectory | r/w | Non | Oui | Oui |
+| `data/webviews/webfs/persistent/local__0` | dataDirectory | r/w | Oui | Non | Oui |
+| `file:///Accounts/1000/Removable/sdcard` | externalRemovableDirectory | r/w | Oui | Non | Non |
+| `file:///Accounts/1000/Shared` | sharedDirectory | r/w | Oui | Non | Non |
+
+*Remarque*: lorsque l'application est déployée dans le périmètre de travail, tous les chemins sont par rapport à /accounts/1000-enterprise.
## Quirks Android
@@ -88,23 +148,24 @@ Il y a plusieurs emplacements valides pour stocker des fichiers persistants sur
Les versions précédentes du plugin choisirait l'emplacement des fichiers temporaires et persistantes au démarrage, basé sur la question de savoir si le dispositif réclamé que la carte SD (ou une partition de stockage équivalent) a été montée. Si la carte SD a été montée, ou si une partition de stockage interne importante était disponible (comme sur les appareils Nexus,) puis les fichiers persistants seraient stockés dans la racine de cet espace. Cela signifie que toutes les apps de Cordova pouvaient voir tous les fichiers disponibles sur la carte.
-Si la carte SD n'était pas disponible, alors les versions précédentes seraient stocker des données sous/données/data /<packageid>, qui isole les apps de l'autre, mais peuvent encore provoquer des données à partager entre les utilisateurs.
+Si la carte SD n'était pas disponible, les versions précédentes pourraient stocker des données sous `/data/data/<packageId>` , qui isole des apps de l'autre, mais peut encore cause données à partager entre les utilisateurs.
-Il est maintenant possible de choisir de stocker les fichiers dans l'emplacement de stockage de fichier interne, ou en utilisant la logique précédente, avec une préférence dans le fichier config.xml de votre application. Pour ce faire, ajoutez l'un des ces deux lignes au fichier config.xml :
+Il est maintenant possible de choisir de stocker les fichiers dans l'emplacement de stockage de fichier interne, ou en utilisant la logique précédente, avec une préférence au sein de votre application `config.xml` fichier. Pour ce faire, ajoutez l'un de ces deux lignes de `config.xml` :
<preference name="AndroidPersistentFileLocation" value="Internal" />
<preference name="AndroidPersistentFileLocation" value="Compatibility" />
-Sans cette ligne, le fichier plugin utilisera la valeur par défaut « Compatibilité ». Si une balise de préférence est présente et n'est pas une des valeurs suivantes, l'application ne démarrera pas.
+Sans cette ligne, utilisera le fichier plugin `Compatibility` par défaut. Si une balise de préférence est présente et n'est pas une des valeurs suivantes, l'application ne démarrera pas.
-Si votre application a déjà été expédiée aux utilisateurs, en utilisant une ancienne (avant 1.0) version de ce plugin et dispose des fichiers stockés dans le système de fichiers persistant, alors vous devez définir la préférence à la « Compatibilité ». Commutation de l'emplacement « Internal » signifierait que les utilisateurs existants qui mettre à niveau leur application peuvent être impossible d'accéder à leurs fichiers déjà enregistrés, selon leur appareil.
+Si votre application a déjà été expédiée aux utilisateurs, en utilisant une ancienne (avant 1.0) version de ce plugin et dispose des fichiers stockés dans le système de fichiers persistant, alors vous devez définir la préférence au `Compatibility` . Commutation de l'emplacement « Internal » signifierait que les utilisateurs existants qui mettre à niveau leur application peuvent être impossible d'accéder à leurs fichiers déjà enregistrés, selon leur appareil.
-Si votre application est nouvelle ou a jamais précédemment stocké les fichiers dans le système de fichiers persistant, alors le paramètre « interne » est généralement recommandé.
+Si votre application est nouvelle ou a jamais précédemment stocké les fichiers dans le système de fichiers persistant, puis la `Internal` réglage est généralement recommandé.
## iOS Quirks
+* `cordova.file.applicationStorageDirectory`est en lecture seule ; tentative de stocker des fichiers dans le répertoire racine échoue. Utilisez l'une de l'autre `cordova.file.*` les propriétés définies pour iOS (seulement `applicationDirectory` et `applicationStorageDirectory` sont en lecture seule).
* `FileReader.readAsText(blob, encoding)`
* Le `encoding` paramètre n'est pas pris en charge, et le codage UTF-8 est toujours en vigueur.
@@ -112,28 +173,29 @@ Si votre application est nouvelle ou a jamais précédemment stocké les fichier
Il y a deux emplacements valides pour stocker des fichiers persistants sur un appareil iOS : le répertoire de Documents et le répertoire de la bibliothèque. Les versions précédentes du plugin stockaient ne jamais fichiers persistants dans le répertoire de Documents. Cela a eu l'effet secondaire de rendre tous les fichiers de l'application visible dans iTunes, qui était souvent inattendus, en particulier pour les applications qui traitent beaucoup de petits fichiers, plutôt que de produire des documents complets destinés à l'exportation, qui est l'objectif visé par le répertoire.
-Il est maintenant possible de choisir de stocker les fichiers dans le répertoire de bibliothèque, avec une préférence dans le fichier config.xml de votre application ou de documents. Pour ce faire, ajoutez l'un des ces deux lignes au fichier config.xml :
+Il est maintenant possible de choisir de stocker les fichiers dans le répertoire de bibliothèque, avec une préférence au sein de votre application ou de documents `config.xml` fichier. Pour ce faire, ajoutez l'un de ces deux lignes de `config.xml` :
<preference name="iosPersistentFileLocation" value="Library" />
<preference name="iosPersistentFileLocation" value="Compatibility" />
-Sans cette ligne, le fichier plugin utilisera la valeur par défaut « Compatibilité ». Si une balise de préférence est présente et n'est pas une des valeurs suivantes, l'application ne démarrera pas.
+Sans cette ligne, utilisera le fichier plugin `Compatibility` par défaut. Si une balise de préférence est présente et n'est pas une des valeurs suivantes, l'application ne démarrera pas.
-Si votre application a déjà été expédiée aux utilisateurs, en utilisant une ancienne (avant 1.0) version de ce plugin et dispose des fichiers stockés dans le système de fichiers persistant, alors vous devez définir la préférence à la « Compatibilité ». L'emplacement de la « Bibliothèque » de commutation signifierait que les utilisateurs existants qui mettre à niveau leur application serait incapables d'accéder à leurs fichiers déjà enregistrés.
+Si votre application a déjà été expédiée aux utilisateurs, en utilisant une ancienne (avant 1.0) version de ce plugin et dispose des fichiers stockés dans le système de fichiers persistant, alors vous devez définir la préférence au `Compatibility` . Changer l'emplacement de `Library` voudrait dire que les utilisateurs existants qui mettre à niveau leur application serait incapables d'accéder à leurs fichiers déjà enregistrés.
-Si votre application est nouvelle ou a jamais précédemment stocké les fichiers dans le système de fichiers persistant, alors le paramètre « Library » est généralement recommandé.
+Si votre application est nouvelle ou a jamais précédemment stocké les fichiers dans le système de fichiers persistant, puis la `Library` réglage est généralement recommandé.
-### Firefox OS Quirks
+## Firefox OS Quirks
L'API de système de fichier n'est pas nativement pris en charge par Firefox OS et est implémentée comme une cale d'épaisseur sur le dessus d'indexedDB.
* Ne manque pas lors de la suppression des répertoires non vide
* Ne supporte pas les métadonnées pour les répertoires
-* Ne prend pas en charge `requestAllFileSystems` et `resolveLocalFileSystemURI` méthodes
* Méthodes `copyTo` et `moveTo` ne prennent pas en charge les répertoires
+Les chemins de données suivants sont pris en charge: * `applicationDirectory` -utilise `xhr` pour obtenir des fichiers les qui sont emballés avec le $ $ etAPP. * `dataDirectory` - Pour les fichiers de données persistantes de app spécifique. * `cacheDirectory` -Mise en cache de fichiers qui doivent survivre les redémarrages de l'application (les applications ne doivent pas compter sur le système d'exploitation pour supprimer les fichiers ici).
+
## Notes de mise à niveau
Dans v1.0.0 de ce plugin, la `FileEntry` et `DirectoryEntry` structures ont changé, pour être plus conforme à la spécification publiée.
@@ -153,7 +215,7 @@ Avec v1.0.0, le `fullPath` attribut contient le chemin vers le fichier, *par rap
Si votre application fonctionne avec le dispositif-absolu-chemins, et que vous avez récupéré précédemment ces chemins à travers la `fullPath` propriété de `Entry` objets, puis vous devez mettre à jour votre code d'utiliser `entry.toURL()` à la place.
-Pour vers l'arrière compatibilité, la `resolveLocalFileSystemURL()` méthode acceptera un chemin absolu de l'unité et retournera un `Entry` objet correspond, tant que ce fichier existe au sein des systèmes de fichiers temporaires ou permanents.
+Pour vers l'arrière compatibilité, le `resolveLocalFileSystemURL()` méthode acceptera un chemin absolu de l'unité et retournera un `Entry` objet correspond, tant que ce fichier existe au sein de soit le `TEMPORARY` ou `PERSISTENT` systèmes de fichiers.
Cela a été particulièrement un problème avec le plugin de transfert de fichiers, qui autrefois périphérique-absolu-chemins (et peut encore accepter). Il a été mis à jour pour fonctionner correctement avec des URL de système de fichiers, remplaçant ainsi `entry.fullPath` avec `entry.toURL()` devrait résoudre tout problème obtenir ce plugin pour travailler avec des fichiers sur le périphérique.
@@ -168,18 +230,20 @@ qui peut servir à identifier de manière unique le fichier.
Lorsqu'une erreur est levée, l'un des codes suivants sera utilisé.
-* 1 = NOT\_FOUND\_ERR
-* 2 = SECURITY_ERR
-* 3 = ABORT_ERR
-* 4 = NOT\_READABLE\_ERR
-* 5 = ENCODING_ERR
-* 6 = NO\_MODIFICATION\_ALLOWED_ERR
-* 7 = INVALID\_STATE\_ERR
-* 8 = SYNTAX_ERR
-* 9 = INVALID\_MODIFICATION\_ERR
-* 10 = QUOTA\_EXCEEDED\_ERR
-* 11 = TYPE\_MISMATCH\_ERR
-* 12 = PATH\_EXISTS\_ERR
+| Code | Constant |
+| ----:|:----------------------------- |
+| 1 | `NOT_FOUND_ERR` |
+| 2 | `SECURITY_ERR` |
+| 3 | `ABORT_ERR` |
+| 4 | `NOT_READABLE_ERR` |
+| 5 | `ENCODING_ERR` |
+| 6 | `NO_MODIFICATION_ALLOWED_ERR` |
+| 7 | `INVALID_STATE_ERR` |
+| 8 | `SYNTAX_ERR` |
+| 9 | `INVALID_MODIFICATION_ERR` |
+| 10 | `QUOTA_EXCEEDED_ERR` |
+| 11 | `TYPE_MISMATCH_ERR` |
+| 12 | `PATH_EXISTS_ERR` |
## Configuration du Plugin (facultatif)
@@ -191,21 +255,21 @@ L'ensemble des systèmes de fichiers disponibles peut être configurée par plat
### Android
-* fichiers : répertoire de stockage de fichier interne de l'application
-* fichiers externes : répertoire de l'application de stockage de fichier externe
-* carte SD : le répertoire de stockage global fichier externe (c'est la racine de la carte SD, s'il est installé). Vous devez avoir la `android.permission.WRITE_EXTERNAL_STORAGE` permission de l'utiliser.
-* cache : répertoire de cache interne de l'application
-* cache-externe : répertoire de cache externe de l'application
-* racine : le système de fichiers de tout dispositif
+* `files`: Répertoire de stockage de l'application le fichier interne
+* `files-external`: Répertoire de stockage de l'application le fichier externe
+* `sdcard`: Le répertoire de stockage global fichier externe (c'est la racine de la carte SD, s'il est installé). Vous devez avoir la `android.permission.WRITE_EXTERNAL_STORAGE` permission de l'utiliser.
+* `cache`: Répertoire de cache interne de l'application
+* `cache-external`: Répertoire de cache externe de l'application
+* `root`: Le système de fichiers de tout dispositif
Android prend également en charge un système de fichiers spécial nommé « documents », qui représente un sous-répertoire « / Documents / » dans le système de fichiers « files ».
### iOS
-* Bibliothèque : répertoire de bibliothèque de l'application
-* documents : répertoire de Documents de l'application
-* cache : répertoire de Cache de l'application
-* Bundle : bundle de l'application ; l'emplacement de l'application elle-même sur disque (lecture seule)
-* racine : le système de fichiers de tout dispositif
+* `library`: Répertoire de l'application la
+* `documents`: Répertoire de Documents de l'application la
+* `cache`: Répertoire du Cache de l'application la
+* `bundle`: Bundle de l'application ; l'emplacement de l'application elle-même sur disque (lecture seule)
+* `root`: Le système de fichiers de tout dispositif
-Par défaut, vous peuvent synchroniser les répertoires de la bibliothèque et les documents à iCloud. Vous pouvez également demander des deux systèmes de fichiers supplémentaires, « bibliothèque-nosync » et « documents-nosync », qui représentent un répertoire spécial non synchronisées dans le système de fichiers de bibliothèque ou de Documents.
\ No newline at end of file
+Par défaut, vous peuvent synchroniser les répertoires de la bibliothèque et les documents à iCloud. Vous pouvez également demander des deux autres systèmes de fichiers, `library-nosync` et `documents-nosync` , qui représentent un répertoire spécial non synchronisées dans le `/Library` ou `/Documents` système de fichiers.
\ No newline at end of file