openEventsPlatformApp/plugins/cordova-plugin-file/doc/it/index.md
plugins/cordova-plugin-file/doc/it/index.mdRaw
1<!---
2 Licensed to the Apache Software Foundation (ASF) under one
3 or more contributor license agreements. See the NOTICE file
4 distributed with this work for additional information
5 regarding copyright ownership. The ASF licenses this file
6 to you under the Apache License, Version 2.0 (the
7 "License"); you may not use this file except in compliance
8 with the License. You may obtain a copy of the License at
9
10 http://www.apache.org/licenses/LICENSE-2.0
11
12 Unless required by applicable law or agreed to in writing,
13 software distributed under the License is distributed on an
14 "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 KIND, either express or implied. See the License for the
16 specific language governing permissions and limitations
17 under the License.
18-->
19
20# cordova-plugin-file
21
22Questo plugin implementa un API File permettendo l'accesso di lettura/scrittura ai file che risiedono sul dispositivo.
23
24Questo plugin si basa su diverse specifiche, tra cui: The HTML5 File API <http://www.w3.org/TR/FileAPI/>
25
26Le directory (ormai defunta) e il sistema delle estensioni più recenti: <http://www.w3.org/TR/2012/WD-file-system-api-20120417/> anche se la maggior parte del codice plugin è stato scritto quando una spec precedenti era corrente: <http://www.w3.org/TR/2011/WD-file-system-api-20110419/>
27
28Implementa inoltre FileWriter spec: <http://dev.w3.org/2009/dap/file-system/file-writer.html>
29
30Per l'utilizzo, fare riferimento a HTML5 Rocks' eccellente [articolo FileSystem.][1]
31
32 [1]: http://www.html5rocks.com/en/tutorials/file/filesystem/
33
34Per una panoramica delle altre opzioni di archiviazione, consultare [Guida di archiviazione di Cordova][2].
35
36 [2]: http://cordova.apache.org/docs/en/edge/cordova_storage_storage.md.html
37
38Questo plugin definisce oggetto global `cordova.file`.
39
40Anche se in ambito globale, non è disponibile fino a dopo l'evento `deviceready`.
41
42 document.addEventListener("deviceready", onDeviceReady, false);
43 function onDeviceReady() {
44 console.log(cordova.file);
45 }
46
47
48## Installazione
49
50 cordova plugin add cordova-plugin-file
51
52
53## Piattaforme supportate
54
55* Amazon fuoco OS
56* Android
57* BlackBerry 10
58* Firefox OS
59* iOS
60* Windows Phone 7 e 8 *
61* Windows 8 *
62* Browser
63
64* *Queste piattaforme non supportano `FileReader.readAsArrayBuffer` né `FileWriter.write(blob)`.*
65
66## Dove memorizzare i file
67
68A partire dalla v 1.2.0, vengono forniti gli URL per le directory importanti file di sistema. Ogni URL è nella forma *file:///path/to/spot/* e può essere convertito in un `DirectoryEntry` utilizzando `window.resolveLocalFileSystemURL()`.
69
70* `cordova.file.applicationDirectory`-Sola lettura directory dove è installato l'applicazione. (*iOS*, *Android*, *BlackBerry 10*)
71
72* `cordova.file.applicationStorageDirectory`-Directory radice di sandbox dell'applicazione; su iOS questa posizione è in sola lettura (ma sottodirectory specifiche [come `/Documents` ] sono di sola lettura). Tutti i dati contenuti all'interno è privato all'app. ( *iOS*, *Android*, *BlackBerry 10*)
73
74* `cordova.file.dataDirectory`-Archiviazione dati persistente e privati nella sandbox dell'applicazione utilizzando la memoria interna (su Android, se è necessario utilizzare la memoria esterna, utilizzare `.externalDataDirectory` ). IOS, questa directory non è sincronizzata con iCloud (utilizzare `.syncedDataDirectory` ). (*iOS*, *Android*, *BlackBerry 10*)
75
76* `cordova.file.cacheDirectory`-Directory per i file memorizzati nella cache di dati o qualsiasi file che app possibile ricreare facilmente. L'OS può eliminare questi file quando il dispositivo viene eseguito basso sull'archiviazione, tuttavia, apps non deve basarsi sul sistema operativo per cancellare i file qui. (*iOS*, *Android*, *BlackBerry 10*)
77
78* `cordova.file.externalApplicationStorageDirectory`-Spazio applicazione su storage esterno. (*Android*)
79
80* `cordova.file.externalDataDirectory`-Dove mettere i file di dati specifico app su storage esterno. (*Android*)
81
82* `cordova.file.externalCacheDirectory`-Cache applicazione su storage esterno. (*Android*)
83
84* `cordova.file.externalRootDirectory`-Radice di archiviazione esterna (scheda SD). (*Android*, *BlackBerry, 10*)
85
86* `cordova.file.tempDirectory`-Temp directory che l'OS è possibile cancellare a volontà. Non fare affidamento sul sistema operativo per cancellare questa directory; l'app deve sempre rimuovere file come applicabile. (*iOS*)
87
88* `cordova.file.syncedDataDirectory`-Contiene i file app specifiche che devono essere sincronizzati (per esempio a iCloud). (*iOS*)
89
90* `cordova.file.documentsDirectory`-I file privati per le app, ma che sono significativi per altre applicazioni (ad esempio i file di Office). (*iOS*)
91
92* `cordova.file.sharedDirectory`-File disponibili globalmente a tutte le applicazioni (*BlackBerry 10*)
93
94## Layout dei file di sistema
95
96Anche se tecnicamente un dettaglio di implementazione, può essere molto utile per conoscere come le proprietà `cordova.file.*` mappa di percorsi fisici su un dispositivo reale.
97
98### iOS File sistema Layout
99
100| Percorso dispositivo | `Cordova.file.*` | `iosExtraFileSystems` | r/w? | persistente? | OS cancella | sincronizzazione | privato |
101|:-------------------------------------------- |:--------------------------- |:--------------------- |:----:|:------------:|:-----------:|:----------------:|:-------:|
102| `/ var/mobile/Applications/< UUID > /` | applicationStorageDirectory | - | r | N/A | N/A | N/A | Sì |
103| `appname.app/` | applicationDirectory | bundle | r | N/A | N/A | N/A | Sì |
104| `www/` | - | - | r | N/A | N/A | N/A | Sì |
105| `Documents/` | documentsDirectory | documenti | r/w | Sì | No | Sì | Sì |
106| `NoCloud/` | - | nosync-documenti | r/w | Sì | No | No | Sì |
107| `Library` | - | libreria | r/w | Sì | No | Sì? | Sì |
108| `NoCloud/` | dataDirectory | nosync-libreria | r/w | Sì | No | No | Sì |
109| `Cloud/` | syncedDataDirectory | - | r/w | Sì | No | Sì | Sì |
110| `Caches/` | cacheDirectory | cache | r/w | Sì * | Sì * * *| | No | Sì |
111| `tmp/` | tempDirectory | - | r/w | No * * | Sì * * *| | No | Sì |
112
113* File persistono attraverso riavvii app e aggiornamenti, ma questa directory può essere azzerata ogni volta che desideri l'OS. L'app dovrebbe essere in grado di ricreare qualsiasi contenuto che potrebbe essere eliminato.
114
115* * File può persistere attraverso app riavvii, ma non fare affidamento su questo comportamento. I file non sono garantiti a persistere attraverso gli aggiornamenti. L'app deve rimuovere i file dalla directory quando è applicabile, come il sistema operativo non garantisce quando (o anche se) questi file vengono rimossi.
116
117* * *| Il sistema operativo può cancellare il contenuto di questa directory ogni volta che si sente è necessario, ma non fare affidamento su questo. Si dovrebbe cancellare questa directory come adatto per l'applicazione.
118
119### Layout sistema Android File
120
121| Percorso dispositivo | `Cordova.file.*` | `AndroidExtraFileSystems` | r/w? | persistente? | OS cancella | privato |
122|:--------------------------------- |:----------------------------------- |:------------------------- |:----:|:------------:|:-----------:|:-------:|
123| `File:///android_asset/` | applicationDirectory | | r | N/A | N/A | Sì |
124| `< app-id > /dati/dati / /` | applicationStorageDirectory | - | r/w | N/A | N/A | Sì |
125| `cache` | cacheDirectory | cache | r/w | Sì | Sì * | Sì |
126| `files` | dataDirectory | file | r/w | Sì | No | Sì |
127| `Documents` | | documenti | r/w | Sì | No | Sì |
128| `< sdcard > /` | externalRootDirectory | sdcard | r/w | Sì | No | No |
129| `Android/data/<app-id>/` | externalApplicationStorageDirectory | - | r/w | Sì | No | No |
130| `cache` | externalCacheDirectry | cache-esterno | r/w | Sì | No * * | No |
131| `files` | externalDataDirectory | file-esterno | r/w | Sì | No | No |
132
133* Il sistema operativo può cancellare periodicamente questa directory, ma non fare affidamento su questo comportamento. Cancellare il contenuto di questa directory come adatto per l'applicazione. Il contenuto di questa directory dovrebbe un utente eliminare manualmente la cache, vengono rimossi.
134
135* * Il sistema operativo non cancella questa directory automaticamente; Tu sei responsabile per la gestione dei contenuti da soli. Il contenuto della directory dovrebbe l'utente eliminare manualmente la cache, vengono rimossi.
136
137**Nota**: se la memorizzazione esterna non può essere montato, le proprietà `cordova.file.external*` sono `null`.
138
139### BlackBerry 10 File sistema Layout
140
141| Percorso dispositivo | `Cordova.file.*` | r/w? | persistente? | OS cancella | privato |
142|:--------------------------------------------------- |:--------------------------- |:----:|:------------:|:-----------:|:-------:|
143| `File:///accounts/1000/AppData/ < id app > /` | applicationStorageDirectory | r | N/A | N/A | Sì |
144| `app/native` | applicationDirectory | r | N/A | N/A | Sì |
145| `data/webviews/webfs/temporary/local__0` | cacheDirectory | r/w | No | Sì | Sì |
146| `data/webviews/webfs/persistent/local__0` | dataDirectory | r/w | Sì | No | Sì |
147| `File:///accounts/1000/Removable/sdcard` | externalRemovableDirectory | r/w | Sì | No | No |
148| `File:///accounts/1000/Shared` | sharedDirectory | r/w | Sì | No | No |
149
150*Nota*: quando l'applicazione viene distribuita a lavorare perimetrale, tutti i percorsi sono relativi a /accounts/1000-enterprise.
151
152## Stranezze Android
153
154### Posizione di archiviazione persistente Android
155
156Ci sono più percorsi validi per memorizzare i file persistenti su un dispositivo Android. Vedi [questa pagina][3] per un'ampia discussione delle varie possibilità.
157
158 [3]: http://developer.android.com/guide/topics/data/data-storage.html
159
160Versioni precedenti del plugin avrebbe scelto il percorso dei file temporanei e permanenti su avvio, in base se il dispositivo ha sostenuto che la scheda SD (o partizione storage equivalente) è stato montato. Se è stata montata sulla scheda SD o una partizione di storage interno grande era disponibile (come sui dispositivi Nexus,) allora saranno memorizzati i file persistenti nella radice di quello spazio. Questo significava che tutte le apps di Cordova poteva vedere tutti i file disponibili sulla carta.
161
162Se la scheda SD non era disponibile, poi versioni precedenti vuoi memorizzare dati sotto `/data/data/<packageId>`, che isola i apps da altro, ma può ancora causa dati da condividere tra gli utenti.
163
164Ora è possibile scegliere se memorizzare i file nel percorso di archiviazione di file interno o utilizzando la logica precedente, con una preferenza nel file `config. xml` dell'applicazione. Per fare questo, aggiungere una di queste due linee al `file config. xml`:
165
166 <preference name="AndroidPersistentFileLocation" value="Internal" />
167
168 <preference name="AndroidPersistentFileLocation" value="Compatibility" />
169
170
171Senza questa linea, il File del plugin utilizzerà la `Compatibility` come predefinito. Se è presente un tag di preferenza e non è uno di questi valori, l'applicazione non si avvia.
172
173Se l'applicazione è stato spedito in precedenza agli utenti, utilizzando un vecchio (pre-1.0) versione di questo plugin e ha i file memorizzati nel filesystem persistente, allora si dovrebbe impostare la preferenza di `Compatibility`. La posizione su "Interno" di commutazione significherebbe che gli utenti esistenti che aggiornare la loro applicazione potrebbero essere Impossibile accedere ai loro file precedentemente memorizzati, a seconda del loro dispositivo.
174
175Se l'applicazione è nuova, o ha mai precedentemente memorizzati i file nel filesystem persistente, è generalmente consigliato l'impostazione `Internal`.
176
177## iOS stranezze
178
179* `cordova.file.applicationStorageDirectory`è di sola lettura; tentativo di memorizzare i file all'interno della directory radice avrà esito negativo. Utilizzare uno degli altri `cordova.file.*` proprietà definite per iOS (solo `applicationDirectory` e `applicationStorageDirectory` sono di sola lettura).
180* `FileReader.readAsText(blob, encoding)`
181 * Il `encoding` parametro non è supportato, e codifica UTF-8 è sempre attivo.
182
183### posizione di archiviazione persistente di iOS
184
185Ci sono due percorsi validi per memorizzare i file persistenti su un dispositivo iOS: la directory documenti e la biblioteca. Precedenti versioni del plugin archiviati solo mai persistenti file nella directory documenti. Questo ha avuto l'effetto collaterale di tutti i file di un'applicazione che rende visibili in iTunes, che era spesso involontaria, soprattutto per le applicazioni che gestiscono un sacco di piccoli file, piuttosto che produrre documenti completi per l'esportazione, che è la destinazione della directory.
186
187Ora è possibile scegliere se memorizzare i file nella directory di libreria, con una preferenza nel file `config. xml` dell'applicazione o documenti. Per fare questo, aggiungere una di queste due linee al `file config. xml`:
188
189 <preference name="iosPersistentFileLocation" value="Library" />
190
191 <preference name="iosPersistentFileLocation" value="Compatibility" />
192
193
194Senza questa linea, il File del plugin utilizzerà la `Compatibility` come predefinito. Se è presente un tag di preferenza e non è uno di questi valori, l'applicazione non si avvia.
195
196Se l'applicazione è stato spedito in precedenza agli utenti, utilizzando un vecchio (pre-1.0) versione di questo plugin e ha i file memorizzati nel filesystem persistente, allora si dovrebbe impostare la preferenza di `Compatibility`. La posizione di commutazione alla `libreria` significherebbe che gli utenti esistenti che aggiornare la loro applicazione è in grado di accedere ai loro file precedentemente memorizzati.
197
198Se l'applicazione è nuova, o ha mai precedentemente memorizzati i file nel filesystem persistente, è generalmente consigliato l'impostazione della `Library`.
199
200## Firefox OS stranezze
201
202L'API di sistema del File non è supportato nativamente dal sistema operativo Firefox e viene implementato come uno spessore in cima indexedDB.
203
204* Non manca quando si rimuove le directory non vuota
205* Non supporta i metadati per le directory
206* Metodi `copyTo` e `moveTo` non supporta le directory
207
208Sono supportati i seguenti percorsi di dati: * `applicationDirectory` - utilizza `xhr` per ottenere i file locali che sono confezionati con l'app. *`dataDirectory` - per i file di dati persistenti app specifiche. *`cacheDirectory` - file memorizzati nella cache che dovrebbe sopravvivere si riavvia app (applicazioni non devono basarsi sull'OS di eliminare i file qui).
209
210## Stranezze browser
211
212### Stranezze e osservazioni comuni
213
214* Ogni browser utilizza il proprio filesystem in modalità sandbox. IE e Firefox utilizzare IndexedDB come base. Tutti i browser utilizzano barra come separatore di directory in un percorso.
215* Le voci di directory devono essere creato successivamente. Ad esempio, la chiamata `fs.root.getDirectory (' dir1/dir2 ', {create:true}, successCallback, errorCallback)` non riuscirà se non esistesse dir1.
216* Il plugin richiede autorizzazione utente per utilizzare un archivio permanente presso il primo avvio dell'applicazione.
217* Plugin supporta `cdvfile://localhost` (risorse locali) solo. Cioè risorse esterne non sono supportate tramite `cdvfile`.
218* Il plugin non segue ["Limitazioni di denominazione 8.3 File sistema API"][4].
219* BLOB e File' `close` la funzione non è supportata.
220* `FileSaver` e `BlobBuilder` non sono supportati da questo plugin e non hanno gli stub.
221* Il plugin non supporta `requestAllFileSystems`. Questa funzione manca anche nelle specifiche.
222* Entrate nella directory non verranno rimossi se si utilizza `create: true` bandiera per directory esistente.
223* Non sono supportati i file creati tramite il costruttore. È invece necessario utilizzare il metodo entry.file.
224* Ogni browser utilizza la propria forma per riferimenti URL blob.
225* `readAsDataURL` funzione è supportata, ma il mediatype in Chrome dipende dall'estensione di voce, mediatype in IE è sempre vuota (che è lo stesso come `text-plain` secondo la specifica), il mediatype in Firefox è sempre `application/octet-stream`. Ad esempio, se il contenuto è `abcdefg` quindi Firefox restituisce `dati: applicazione / octet-stream; base64, YWJjZGVmZw = =`, cioè restituisce `dati:; base64, YWJjZGVmZw = =`, Chrome restituisce `dati: < mediatype a seconda dell'estensione del nome della voce >; base64, YWJjZGVmZw = =`.
226* `toInternalURL` restituisce il percorso in forma `file:///persistent/path/to/entry` (Firefox, IE). Chrome restituisce il percorso nella forma `cdvfile://localhost/persistent/file`.
227
228 [4]: http://www.w3.org/TR/2011/WD-file-system-api-20110419/#naming-restrictions
229
230### Stranezze di cromo
231
232* Cromo filesystem non è subito pronto dopo evento ready dispositivo. Come soluzione alternativa, è possibile iscriversi all'evento `filePluginIsReady`. Esempio:
233
234 javascript
235 window.addEventListener('filePluginIsReady', function(){ console.log('File plugin is ready');}, false);
236
237
238È possibile utilizzare la funzione `window.isFilePluginReadyRaised` per verificare se evento già è stato generato. -quote di filesystem TEMPORARY e PERSISTENT window.requestFileSystem non sono limitate in Chrome. -Per aumentare la memoria persistente in Chrome è necessario chiamare il metodo `window.initPersistentFileSystem`. Quota di archiviazione persistente è di 5 MB per impostazione predefinita. -Chrome richiede `-consentire-file-accesso-da-file` eseguire argomento a supporto API tramite protocollo `file:///`. -`File` oggetto non cambierà se si utilizza il flag `{create:true}` quando ottenendo un' esistente `entrata`. -eventi `cancelable` è impostata su true in Chrome. Ciò è in contrasto con la [specifica][5]. -funzione `toURL` Chrome restituisce `filesystem:`-premessi percorso a seconda dell'applicazione host. Ad esempio, `filesystem:file:///persistent/somefile.txt`, `filesystem:http://localhost:8080/persistent/somefile.txt`. -`toURL` risultato di funzione non contiene una barra finale in caso di voce di directory. Chrome risolve le directory con gli URL slash-trainati però correttamente. -`resolveLocalFileSystemURL` metodo richiede in ingresso `url` avere il prefisso del `file System`. Ad esempio, il parametro `url` per `resolveLocalFileSystemURL` dovrebbe essere nella forma `filesystem:file:///persistent/somefile.txt` in contrasto con la forma `file:///persistent/somefile.txt` in Android. -Obsoleto `toNativeURL` funzione non è supportata e non dispone di uno stub. -funzione `setMetadata` non è indicato nelle specifiche e non supportato. -INVALID_MODIFICATION_ERR (codice: 9) viene generata invece di SYNTAX_ERR(code: 8) su richiesta di un filesystem inesistente. -INVALID_MODIFICATION_ERR (codice: 9) viene generata invece di PATH_EXISTS_ERR(code: 12) sul tentativo di creare esclusivamente un file o una directory, che esiste già. -INVALID_MODIFICATION_ERR (codice: 9) viene generata invece di NO_MODIFICATION_ALLOWED_ERR(code: 6) sul tentativo di chiamare removeRecursively su file system root. -INVALID_MODIFICATION_ERR (codice: 9) viene generata invece di NOT_FOUND_ERR(code: 1) sul tentativo moveTo directory che non esiste.
239
240 [5]: http://dev.w3.org/2009/dap/file-system/file-writer.html
241
242### Stranezze impl IndexedDB-basato (Firefox e IE)
243
244* `.` e `.` non sono supportati.
245* IE non supporta `file:///`-modalità; modalità solo ospitata è supportato (http://localhost:xxxx).
246* Dimensione filesystem Firefox non è limitata, ma ogni estensione 50MB sarà richiesta un'autorizzazione dell'utente. IE10 consente fino a 10mb di combinato AppCache e IndexedDB utilizzato nell'implementazione del filesystem senza chiedere conferma, una volta premuto quel livello che vi verrà chiesto se si desidera consentire ad essere aumentata fino a un max di 250 mb per ogni sito. Quindi la `size` parametro per la funzione `requestFileSystem` non influisce il filesystem in Firefox e IE.
247* `readAsBinaryString` funzione non è indicato nelle specifiche e non supportati in IE e non dispone di uno stub.
248* `file.Type` è sempre null.
249* Non è necessario creare la voce utilizzando il risultato del callback istanza DirectoryEntry che è stato eliminato. In caso contrario, si otterrà una 'voce di sospensione'.
250* Prima è possibile leggere un file che è stato appena scritto è necessario ottenere una nuova istanza di questo file.
251* supporta la funzione `setMetadata`, che non è indicato nelle specifiche `modificationTime` cambiamento di campo solo.
252* funzioni `copyTo` e `moveTo` non supporta le directory.
253* Le directory metadati non sono supportato.
254* Sia Entry.remove e directoryEntry.removeRecursively non fallire quando si rimuove le directory non vuota - directory da rimuovere vengono pulite invece insieme al contenuto.
255* `abort` e `truncate` le funzioni non sono supportate.
256* non vengono generati eventi di progresso. Ad esempio, questo gestore verrà non eseguito:
257
258 javascript
259 writer.onprogress = function() { /*commands*/ };
260
261
262## Note di aggiornamento
263
264In v 1.0.0 di questo plugin, le strutture `FileEntry` e `DirectoryEntry` sono cambiati, per essere più in linea con le specifiche pubblicate.
265
266Versioni precedenti (pre-1.0.0) del plugin archiviati il dispositivo-assoluto--percorso del file nella proprietà `fullPath` di oggetti della `voce`. In genere questi percorsi si sarebbe simile
267
268 /var/mobile/Applications/<application UUID>/Documents/path/to/file (iOS)
269 /storage/emulated/0/path/to/file (Android)
270
271
272Questi percorsi sono stati anche restituiti dal metodo `toURL()` degli oggetti `Entry`.
273
274Con v 1.0.0, l'attributo `fullPath` è il percorso del file, *rispetto alla radice del filesystem HTML*. Così, i percorsi sopra sarebbe ora sia rappresentato da un oggetto `FileEntry` con un `fullPath` di
275
276 /path/to/file
277
278
279Se l'applicazione funziona con dispositivo-assoluto-percorsi, e precedentemente recuperato quei percorsi attraverso la proprietà `fullPath` della `voce` oggetti, è necessario aggiornare il codice per utilizzare `entry.toURL()` invece.
280
281Per indietro la compatibilità, il metodo `resolveLocalFileSystemURL()` verrà accettare un dispositivo-assoluto-percorso e restituirà un oggetto di `entrata` corrispondente ad essa, fintanto che il file esiste all'interno del filesystem la `temporanea` o `permanente`.
282
283Questo particolare è stato un problema con il plugin di trasferimento File, che in precedenza utilizzati percorsi-dispositivo-assoluto (e ancora può accoglierli). Esso è stato aggiornato per funzionare correttamente con gli URL di FileSystem, così sostituendo `entry.fullPath` con `entry.toURL()` dovrebbe risolvere eventuali problemi ottenendo quel plugin per lavorare con i file nel dispositivo.
284
285In v 1.1.0 il valore restituito di `toURL()` è stato cambiato (vedere \[CB-6394\] (https://issues.apache.org/jira/browse/CB-6394)) per restituire un URL assoluto 'file://'. ove possibile. Per assicurare un ' cdvfile:'-URL, è possibile utilizzare `toInternalURL()` ora. Questo metodo restituirà ora filesystem URL del modulo
286
287 cdvfile://localhost/persistent/path/to/file
288
289
290che può essere utilizzato per identificare univocamente il file.
291
292## Elenco dei codici di errore e significati
293
294Quando viene generato un errore, uno dei seguenti codici da utilizzare.
295
296| Codice | Costante |
297| ------:|:----------------------------- |
298| 1 | `NOT_FOUND_ERR` |
299| 2 | `SECURITY_ERR` |
300| 3 | `ABORT_ERR` |
301| 4 | `NOT_READABLE_ERR` |
302| 5 | `ENCODING_ERR` |
303| 6 | `NO_MODIFICATION_ALLOWED_ERR` |
304| 7 | `INVALID_STATE_ERR` |
305| 8 | `SYNTAX_ERR` |
306| 9 | `INVALID_MODIFICATION_ERR` |
307| 10 | `QUOTA_EXCEEDED_ERR` |
308| 11 | `TYPE_MISMATCH_ERR` |
309| 12 | `PATH_EXISTS_ERR` |
310
311## Configurare il Plugin (opzionale)
312
313Il set di filesystem disponibili può essere configurato per ogni piattaforma. Sia iOS che Android riconoscere un <preference> Tag nel `file config. xml` che nomina il filesystem per essere installato. Per impostazione predefinita, tutte le radici del file system sono abilitate.
314
315 <preference name="iosExtraFilesystems" value="library,library-nosync,documents,documents-nosync,cache,bundle,root" />
316 <preference name="AndroidExtraFilesystems" value="files,files-external,documents,sdcard,cache,cache-external,root" />
317
318
319### Android
320
321* `files`: directory di archiviazione di file interno dell'applicazione
322* `files-external`: directory di archiviazione dell'applicazione file esterno
323* `sdcard`: la directory di archiviazione di file esterni globale (questa è la radice della scheda SD, se uno è installato). È necessario disporre dell'autorizzazione `android.permission.WRITE_EXTERNAL_STORAGE` utilizzare questo.
324* `cache`: la cache interna directory applicazione
325* `cache-external`: directory di cache esterna dell'applicazione
326* `root`: il dispositivo intero filesystem
327
328Android supporta anche un filesystem speciale denominato "documenti", che rappresenta una sottodirectory "/ documenti /" all'interno del filesystem "files".
329
330### iOS
331
332* `library`: la directory dell'applicazione libreria
333* `documents`: la directory dell'applicazione documenti
334* `cache`: la Cache directory applicazione
335* `bundle`: bundle dell'applicazione; la posizione dell'app sul disco (sola lettura)
336* `root`: il dispositivo intero filesystem
337
338Per impostazione predefinita, la directory di libreria e documenti può essere sincronizzata a iCloud. È anche possibile richiedere due filesystem aggiuntivi, `library-nosync` e `documents-nosync`, che rappresentano una speciale directory non sincronizzati entro il `/Library` o filesystem `/Documents`.