Operazioni con oggetti File in AIR

Adobe AIR 1.0 e versioni successive

L'oggetto File è un puntatore a un file o una directory del file system.

La classe File estende la classe FileReference. La classe FileReference, disponibile in Adobe® Flash® Player e AIR, rappresenta un puntatore a un file. La classe File aggiunge proprietà e metodi che non sono esposti in Flash Player (in un file SWF eseguito in un browser), per motivi di sicurezza.

Informazioni sulla classe File

Potete utilizzare la classe File per le seguenti operazioni:

  • Recupero del percorso di directory speciali, comprese la directory dell'utente, la directory dei documenti dell'utente, quella da cui è stata avviata l'applicazione e la directory dell'applicazione

  • Copiatura di file e directory

  • Spostamento di file e directory

  • Eliminazione di file e directory (o spostamento nel cestino)

  • Elencazione di file e directory contenuti in una directory

  • Creazione di file e cartelle temporanei

Una volta che l'oggetto File punta a un percorso file, potete utilizzarlo per leggere e scrivere dati di file, utilizzando la classe FileStream.

Un oggetto File può puntare al percorso di un file o di una directory che non esiste ancora. Potete utilizzare un oggetto File di questo tipo per creare un file o una directory.

Percorsi degli oggetti File

Ogni oggetto File ha due proprietà che ne definiscono il percorso:

Proprietà

Descrizione

nativePath

Definisce il percorso di un file a una piattaforma specifica. Ad esempio, in Windows un percorso potrebbe essere "c:\Directory esempio\test.txt", mentre in Mac OS potrebbe essere "/Directory esempio/test.txt". Una proprietà nativePath utilizza, come carattere separatore di directory, il carattere barra rovesciata (\) in Windows e il carattere barra (/) in Mac OS e Linux.

url

È possibile utilizzare lo schema URL del file per puntare a un file. Ad esempio, in Windows un percorso potrebbe essere "file:///c:/Sample%20directory/test.txt", mentre in Mac OS potrebbe essere "file:///Sample%20directory/test.txt". Il runtime comprende altri schemi URL speciali oltre a file, descritti in Schemi URL AIR supportati

La classe File comprende proprietà statiche che consentono di puntare a directory standard in Mac OS, Windows e Linux. Tali proprietà includono:

  • File.applicationStorageDirectory - Una directory di archiviazione specifica per ciascuna applicazione AIR installata. Questa directory è appropriata per memorizzare le risorse applicazione dinamiche e le preferenze utente. Valutate l'opportunità di memorizzare grandi quantità di dati altrove.

    Su Android e iOS, la directory di memorizzazione dell'applicazione viene rimossa durante la disinstallazione dell'applicazione o quando l'utente sceglie di cancellare i dati applicazione, ma questo non accade su altre piattaforme.

  • File.applicationDirectory - La directory in cui è installata l'applicazione (con le eventuali risorse installate). In alcuni sistemi operativi, l'applicazione viene memorizzata in un file di pacchetto singolo anziché in una directory fisica. In questo caso, il contenuto potrebbe non essere accessibile utilizzando il percorso nativo. La directory dell'applicazione è di sola lettura.

  • File.desktopDirectory - La directory del desktop dell'utente. Se una piattaforma non definisce una directory desktop, viene utilizzata un'altra posizione del file system.

  • File.documentsDirectory - La directory dei documenti dell'utente. Se una piattaforma non definisce una directory documenti, viene utilizzata un'altra posizione del file system.

  • File.userDirectory - La directory dell'utente. Se una piattaforma non definisce una directory dell'utente, viene utilizzata un'altra posizione del file system.

Nota: quando una piattaforma non definisce posizioni standard per desktop, documenti o directory utente, File.documentsDirectory, File.desktopDirectory e File.userDirectory possono fare riferimento alla stessa directory.

Queste proprietà hanno valori diversi su sistemi operativi differenti. Ad esempio, Mac e Windows prevedono percorsi nativi differenti per la directory del desktop dell'utente. Tuttavia, la proprietà File.desktopDirectory fa riferimento a un percorso di directory appropriato su ogni piattaforma. Per scrivere applicazioni in grado di funzionare senza problemi in più piattaforme, utilizzate queste proprietà come base per fare riferimento ad altri file e directory utilizzati dall'applicazione. Quindi, utilizzate il metodo resolvePath() per definire con precisione il percorso. Ad esempio, questo codice punta al file preferences.xml nella directory di archiviazione dell'applicazione:

var prefsFile:File = File.applicationStorageDirectory; 
prefsFile = prefsFile.resolvePath("preferences.xml");

Sebbene la classe File consenta di fare riferimento a un percorso file specifico, l'applicazione potrebbe non funzionare tra diverse piattaforme. Ad esempio, il percorso C:\Documents and Settings\joe\ funziona solo in Windows. Per tali motivi, è meglio utilizzare le proprietà statiche della classe File, ad esempio File.documentsDirectory.

Percorsi directory comuni

Piattaforma

Tipo di directory

Percorso file system tipico

Android

Applicazione

/data/data/

Application-storage

/data/data/air.applicationID/filename/Local Store

Cache

/data/data/applicationID/cache

Desktop

/mnt/sdcard

Documenti

/mnt/sdcard

Temporanea

/data/data/applicationID/cache/FlashTmp.randomString

Utente

/mnt/sdcard

iOS

Applicazione

/var/mobile/Applications/uid/filename.app

Application-storage

/var/mobile/Applications/uid/Library/Application Support/applicationID/Local Store

Cache

/var/mobile/Applications/uid/Library/Caches

Desktop

non accessibile

Documenti

/var/mobile/Applications/uid/Documents

Temporanea

/private/var/mobile/Applications/uid/tmp/FlashTmpNNN

Utente

non accessibile

Linux

Applicazione

/opt/filename/share

Application-storage

/home/userName/.appdata/applicationID/Local Store

Desktop

/home/userName/Desktop

Documenti

/home/userName/Documents

Temporanea

/tmp/FlashTmp.randomString

Utente

/home/userName

Mac

Applicazione

/Applications/filename.app/Contents/Resources

Application-storage

/Users/nomeUtente/Library/Preferences/applicationid/Local Store (AIR 3.2 e versioni precedenti)

path/Library/Application Support/applicationid/Local Store (AIR 3.3 e versioni successive), dove path è /Users/userName/Library/Containers/bundle-id/Data (ambiente con sandbox) o /Users/userName (al di fuori di un ambiente con sandbox)

Cache

/Users/userName/Library/Caches

Desktop

/Users/userName/Desktop

Documenti

/Users/userName/Documents

Temporanea

/private/var/folders/JY/randomString/TemporaryItems/FlashTmp

Utente

/Users/userName

Windows

Applicazione

C:\Programmi\filename

Application-storage

C:\Documents and settings\userName\ApplicationData\applicationID\Local Store

Cache

C:\Documents and settings\userName\Local Settings\Temp

Desktop

C:\Documents and settings\userName\Desktop

Documenti

C:\Documents and settings\userName\My Documents

Temporanea

C:\Documents and settings\userName\Local Settings\Temp\randomString.tmp

Utente

C:\Documents and settings\userName

I percorsi nativi effettivi per queste directory variano in base al sistema operativo e alla configurazione del computer. I percorsi mostrati in questa tabella sono esempi tipici. Utilizzate sempre le proprietà della classe File statica appropriate per fare riferimento a queste directory in modo che l'applicazione funzioni correttamente su qualsiasi piattaforma. In un'applicazione AIR effettiva, i valori per applicationID e filename mostrati nella tabella sono presi dal descrittore dell'applicazione. Se nel descrittore dell'applicazione specificate un ID editore, questo viene aggiunto all'ID applicazione in questi percorsi. Il valore per userName è il nome account dell'utente che esegue l'installazione.

Puntamento di un oggetto File a una directory

Sono disponibili diversi modi per impostare un oggetto File in modo che punti a una directory.

Puntamento alla directory home dell'utente

È possibile puntare un oggetto File alla directory home dell'utente. Il codice seguente imposta un oggetto File che punta alla sottodirectory AIR Test della directory home:

var file:File = File.userDirectory.resolvePath("AIR Test"); 

Puntamento alla directory Documenti dell'utente

È possibile puntare un oggetto File alla directory Documenti dell'utente. Il codice seguente imposta un oggetto File che punta alla sottodirectory AIR Test della directory Documenti:

var file:File = File.documentsDirectory.resolvePath("AIR Test");

Puntamento alla directory del desktop

È possibile puntare un oggetto File al desktop. Il codice seguente imposta un oggetto File che punta a una sottodirectory AIR Test del desktop:

var file:File = File.desktopDirectory.resolvePath("AIR Test");

Puntamento alla directory di memorizzazione dell'applicazione

È possibile puntare un oggetto File alla directory di memorizzazione dell'applicazione. Per ogni applicazione AIR, vi è un unico percorso associato univoco che definisce la directory di memorizzazione dell'applicazione. Tale directory è unica per ogni applicazione e per ogni utente. Potete utilizzare questa directory per memorizzare dati specifici dell'utente o dell'applicazione (ad esempio i dati dell'utente o i file delle preferenze). Ad esempio, il codice seguente punta un oggetto File a un file di preferenze, prefs.xml, contenuto nella directory di memorizzazione dell'applicazione:

var file:File = File.applicationStorageDirectory; 
file = file.resolvePath("prefs.xml");

Il percorso della directory di archiviazione dell'applicazione è in genere basato sul nome utente e sull'ID applicazione. I percorsi file system seguenti sono forniti qui per semplificare il debug dell'applicazione. Utilizzate sempre la proprietà File.applicationStorage o lo schema URI app-storage: per risolvere file in questa directory:

  • Su Mac OS - in base alla versione AIR:

    AIR 3.2 e versioni precedenti: /Users/nome utente/Library/Preferences/applicationID/Local Store/

    AIR 3.3 e versioni successive: path/Library/Application Support/applicationID/Local Store, dove path è /Users/username/Library/Containers/bundle-id/Data (ambiente con sandbox) oppure /Users/username (al di fuori di un ambiente con sandbox)

    Ad esempio (AIR 3.2):

    /Users/babbage/Library/Preferences/com.example.TestApp/Local Store
  • In Windows, nella directory Documents and Settings, in:

    C:\Documents and Settings\nome utente\Dati applicazioni\applicationID\Local Store\

    Ad esempio:

    C:\Documents and Settings\babbage\Application Data\com.example.TestApp\Local Store
  • In Linux - In:

    /home/nome utente/.appdata/applicationID/Local Store/

    Ad esempio:

    /home/babbage/.appdata/com.example.TestApp/Local Store
  • Su Android, in:

    /data/data/androidPackageID/applicationID/Local Store

    Ad esempio:

    /data/data/air.com.example.TestApp/com.example.TestApp/Local Store
Nota: se un'applicazione dispone di un ID editore, questo viene anche utilizzato come parte del percorso alla directory di archiviazione dell'applicazione.

L'URL (e la proprietà url) di un oggetto File creato tramite File.applicationStorageDirectory utilizza lo schema URL app-storage (consultate Schemi URL AIR supportati), come nel caso seguente:

var dir:File = File.applicationStorageDirectory; 
dir = dir.resolvePath("preferences"); 
trace(dir.url); // app-storage:/preferences

Puntamento alla directory dell'applicazione

È possibile puntare un oggetto File alla directory in cui è stata installata l'applicazione, nota anche come directory dell'applicazione. Potete fare riferimento a questa directory mediante la proprietà File.applicationDirectory. Potete utilizzare questa directory per esaminare il file descrittore dell'applicazione o altre risorse installate con l'applicazione. Ad esempio, il codice seguente punta un oggetto File a una directory denominata images nella directory dell'applicazione:

var dir:File = File.applicationDirectory; 
dir = dir.resolvePath("images"); 

L'URL (e la proprietà url) di un oggetto File creato tramite File.applicationDirectory utilizza lo schema URL app (consultate Schemi URL AIR supportati), come nel caso seguente:

var dir:File = File.applicationDirectory; 
dir = dir.resolvePath("images"); 
trace(dir.url); // app:/images
Nota: su Android, i file nel pacchetto dell'applicazione non sono accessibili tramite la proprietà nativePath. La proprietà nativePath è una stringa vuota. Utilizzate sempre l'URL per accedere ai file nella directory dell'applicazione anziché un percorso nativo.

Puntamento alla directory cache

Potete puntare un oggetto File alla directory temporanea o cache del sistema operativo mediante la proprietà File.cacheDirectory. Questa directory contiene file temporanei non richiesti per l'esecuzione dell'applicazione e l'eliminazione di tali file non provocherà problemi o perdite di dati per l'utente.

Nella maggior parte dei sistemi operativi la directory cache è una directory temporanea. In iOS, la directory cache corrisponde alla directory delle cache della libreria dell'applicazione. I file in questa directory non vengono sottoposti a backup per l'archiviazione in linea e possono essere potenzialmente eliminati dal sistema operativo se lo spazio di archiviazione disponibile nel dispositivo è troppo ridotto. Per maggiori informazioni, vedere Controllo del backup dei file e memorizzazione nella cache.

Puntamento alla directory principale di sistema

Il metodo File.getRootDirectories() elenca tutti i volumi principali, come C: e i volumi montati, di un computer Windows. In Mac OS e Linux, questo metodo restituisce sempre l'unica directory principale della macchina (la directory "/"). Il metodo StorageVolumeInfo.getStorageVolumes() fornisce informazioni più dettagliate sui volumi di memorizzazione montati (vedete Operazioni con volumi di memorizzazione).

Nota: la directory principale del file system non è leggibile su Android. Viene restituito un oggetto File che fa riferimento alla directory con il percorso nativo, “/”, ma le proprietà dell'oggetto non dispongono di valori accurati. Ad esempio, spaceAvailable è sempre 0.

Puntamento a una directory esplicita

È possibile puntare l'oggetto File a una directory esplicita impostandone la proprietà nativePath, come nell'esempio seguente (in Windows):

var file:File = new File(); 
file.nativePath = "C:\\AIR Test";

Importante: puntare a un percorso esplicito in questo modo può portare a codice che non funziona tra piattaforme diverse. Ad esempio, il codice precedente funziona solo in Windows. Potete utilizzare le proprietà statiche dell'oggetto File, ad esempio File.applicationStorageDirectory, per individuare una directory che funziona tra piattaforme diverse. Utilizzate quindi il metodo resolvePath() (vedete la sezione successiva) per passare a un percorso relativo.

Accesso a percorsi relativi

È possibile utilizzare il metodo resolvePath() per ottenere un percorso relativo a un altro percorso specifico. Ad esempio, il codice seguente imposta un oggetto File che punta alla sottodirectory "AIR Test" della directory home dell'utente:

var file:File = File.userDirectory; 
file = file.resolvePath("AIR Test");

Potete anche utilizzare la proprietà url di un oggetto File per puntarlo a una directory in base a una stringa URL, come nel caso seguente:

var urlStr:String = "file:///C:/AIR Test/"; 
var file:File = new File() 
file.url = urlStr; 

Per ulteriori informazioni, consultate Modifica dei percorsi File.

Selezione di una directory da parte dell'utente

La classe File comprende il metodo browseForDirectory(), che presenta una finestra di dialogo di sistema in cui l'utente può selezionare una directory da assegnare all'oggetto. Il metodo browseForDirectory() è asincrono. L'oggetto File invia un evento select se l'utente seleziona una directory e fa clic sul pulsante Apri, oppure un evento cancel se l'utente fa clic sul pulsante Annulla.

Ad esempio, il codice seguente consente all'utente di selezionare una directory e visualizza il percorso della directory una volta eseguita la selezione:

var file:File = new File(); 
file.addEventListener(Event.SELECT, dirSelected); 
file.browseForDirectory("Select a directory"); 
function dirSelected(e:Event):void { 
    trace(file.nativePath); 
}
Nota: su Android, il metodo browseForDirectory() non è supportato. La chiamata di questo metodo non ha effetto; viene inviato immediatamente un evento cancel. Per consentire agli utenti di selezionare una directory, utilizzate una finestra di dialogo personalizzata definita dall'applicazione.

Puntamento alla directory da cui viene chiamata l'applicazione

Potete ottenere la posizione della directory da cui viene chiamata un'applicazione selezionando la proprietà currentDirectory dell'evento InvokeEvent inviato quando l'applicazione viene chiamata. Per informazioni dettagliate, consultate Acquisizione degli argomenti della riga di comando.

Puntamento di un oggetto File a un file

Sono disponibili diversi modi per impostare il file a cui punta un oggetto File.

Puntamento a un percorso file esplicito

Importante: puntare a un percorso esplicito può portare a codice che non funziona tra piattaforme diverse. Ad esempio, il percorso C:/foo.txt funziona solo in Windows. Potete utilizzare le proprietà statiche dell'oggetto File, ad esempio File.applicationStorageDirectory, per individuare una directory che funziona tra piattaforme diverse. Utilizzate quindi il metodo resolvePath() (vedete Modifica dei percorsi File) per passare a un percorso relativo.

Potete utilizzare la proprietà url di un oggetto File per puntarlo a un file o a una directory in base a una stringa URL, come nel caso seguente:

var urlStr:String = "file:///C:/AIR Test/test.txt"; 
var file:File = new File() 
file.url = urlStr; 

Potete anche passare l'URL alla funzione di costruzione File(), come nel caso seguente:

var urlStr:String = "file:///C:/AIR Test/test.txt"; 
var file:File = new File(urlStr); 

La proprietà url restituisce sempre la versione codificata URI dell'URL (ad esempio, gli spazi vuoti vengono sostituiti da "%20):

file.url = "file:///c:/AIR Test"; 
trace(file.url); // file:///c:/AIR%20Test 

Potete anche utilizzare la proprietà nativePath di un oggetto File per impostare un percorso esplicito. Ad esempio, il codice seguente, se eseguito su un computer Windows, imposta un oggetto File sul file test.txt nella sottodirectory AIR Test dell'unità C:

var file:File = new File(); 
file.nativePath = "C:/AIR Test/test.txt"; 

Potete anche passare questo percorso alla funzione di costruzione File(), come nel caso seguente:

var file:File = new File("C:/AIR Test/test.txt"); 

Utilizzate solo il carattere barra (/) come delimitatore percorso per la proprietà nativePath. In Windows, potete anche utilizzare la barra rovesciata (\), ma in questo caso l'applicazione potrebbe non funzionare tra piattaforme diverse.

Per ulteriori informazioni, consultate Modifica dei percorsi File.

Enumerazione dei file di una directory

Potete utilizzare il metodo getDirectoryListing() di un oggetto File per recuperare un array di oggetti File che puntano ai file e alle sottodirectory al livello principale di una directory. Per ulteriori informazioni, consultate Enumerazione delle directory.

Selezione di un file da parte dell'utente

La classe File comprende i metodi che presentano una finestra di dialogo di sistema in cui l'utente può selezionare un file da assegnare all'oggetto.

  • browseForOpen()

  • browseForSave()

  • browseForOpenMultiple()

Questi metodi sono tutti asincroni. I metodi browseForOpen() e browseForSave() inviano l'evento di selezione quando l'utente seleziona un file (o un percorso target, nel caso di browseForSave()). Con i metodi browseForOpen() e browseForSave(), a seguito della selezione l'oggetto File di destinazione punta ai file selezionati. Il metodo browseForOpenMultiple() invia un evento selectMultiple quando l'utente seleziona i file. L'evento selectMultiple è del tipo FileListEvent, che ha una proprietà files che corrisponde a un array di oggetti File (che puntano ai file selezionati).

Ad esempio, il codice seguente mostra all'utente una finestra di dialogo “Apri” in cui l'utente può selezionare un file:

var fileToOpen:File = File.documentsDirectory; 
selectTextFile(fileToOpen); 
 
function selectTextFile(root:File):void 
{ 
    var txtFilter:FileFilter = new FileFilter("Text", "*.as;*.css;*.html;*.txt;*.xml"); 
    root.browseForOpen("Open", [txtFilter]); 
    root.addEventListener(Event.SELECT, fileSelected); 
} 
 
function fileSelected(event:Event):void 
{ 
    trace(fileToOpen.nativePath); 
} 

Se nell'applicazione è aperta un'altra finestra di dialogo di consultazione file quando chiamate un metodo browse, il runtime genera un'eccezione Error.

Nota: su Android, solo file immagine, video e audio possono essere selezionati con i metodi browseForOpen() e browseForOpenMultiple(). La finestra di dialogo browseForSave() contiene solo file multimediali anche se l'utente può immettere un nome file arbitrario. Per l'apertura e il salvataggio di file non multimediali, considerate la possibilità di utilizzare finestre di dialogo personalizzate anziché questi metodi.

Modifica dei percorsi File

Potete inoltre modificare il percorso di un oggetto File esistente chiamando il metodo resolvePath() o modificando la proprietà nativePath o url dell'oggetto, come negli esempi seguenti (in Windows):

var file1:File = File.documentsDirectory; 
file1 = file1.resolvePath("AIR Test"); 
trace(file1.nativePath); // C:\Documents and Settings\userName\My Documents\AIR Test 
var file2:File = File.documentsDirectory; 
file2 = file2.resolvePath(".."); 
trace(file2.nativePath); // C:\Documents and Settings\userName 
var file3:File = File.documentsDirectory; 
file3.nativePath += "/subdirectory"; 
trace(file3.nativePath); // C:\Documents and Settings\userName\My Documents\subdirectory 
var file4:File = new File(); 
file4.url = "file:///c:/AIR Test/test.txt"; 
trace(file4.nativePath); // C:\AIR Test\test.txt 

Con la proprietà nativePath utilizzate il carattere barra (/) come carattere separatore di directory. In Windows, potete utilizzare anche il carattere barra rovesciata (\), ma il suo impiego non è consigliato perché può portare a codice che non funziona tra piattaforme diverse.

Schemi URL AIR supportati

In AIR, potete utilizzare uno qualsiasi dei seguenti schemi URL per definire la proprietà url di un oggetto File:

Schema URL

Descrizione

file

Specifica un percorso relativo alla directory principale del file system. Ad esempio:

file:///c:/AIR Test/test.txt

Lo standard URL specifica che un URL di file assume la forma file://<host>/<path>. Come caso speciale, <host> può essere una stringa vuota, che viene interpretata come "il sistema da cui l'URL viene interpretato". Per questo motivo, gli URL file spesso presentano tre barre (///).

app

Specifica un percorso relativo alla directory principale dell'applicazione installata (la directory contenente il file application.xml dell'applicazione installata). Ad esempio, il percorso seguente punta alla sottodirectory images della directory dell'applicazione installata:

app:/images

app-storage

Specifica un percorso relativo alla directory di memorizzazione dell'applicazione. Per ogni applicazione installata, AIR definisce una directory univoca di memorizzazione dell'applicazione, che costituisce una comoda ubicazione in cui memorizzare i dati specifici di un'applicazione. Ad esempio, il percorso seguente punta a un file prefs.xml in una sottodirectory delle impostazioni della directory di memorizzazione dell'applicazione:

app-storage:/settings/prefs.xml

Controllo del backup dei file e memorizzazione nella cache

Alcuni sistemi operativi, in particolare iOS e Mac OS X, forniscono agli utenti la possibilità di eseguire automaticamente il backup di file applicazione in una posizione di archiviazione remota. Inoltre, i dispositivi iOS presentano restrizioni relative ai file da sottoporre a backup e alle posizioni di archiviazione di file con scopi diversi.

Di seguito vengono riepilogate le modalità per garantire la conformità alle linee guida Apple per l'archiviazione e la memorizzazione di file. Per ulteriori informazioni, consultate le sezioni successive.

  • Per specificare che un file non necessita di backup e che può essere eliminato dal sistema operativo (solo per iOS) se lo spazio di archiviazione del dispositivo non è sufficiente, salvate il file nella directory cache (File.cacheDirectory). Si tratta della posizione di archiviazione preferita nei dispositivi iOS e dovrebbe essere utilizzata per la maggior parte dei file che è possibile rigenerare o scaricare di nuovo.

  • Per specificare che un file non necessita di backup, ma non deve essere eliminato dal sistema operativo, salvate il file in una delle directory delle librerie dell'applicazione, come la directory di archiviazione dell'applicazione (File.applicationStorageDirectory) o la directory dei documenti File.documentsDirectory). Impostate la proprietà preventBackup dell'oggetto File su true. Questa procedura è richiesta da Apple per i contenuti che possono essere rigenerati o scaricati nuovamente ed è necessaria per il corretto funzionamento dell'applicazione durante l'utilizzo non in linea.

Indicazione dei file per il backup

Per risparmiare spazio di backup e ridurre l'utilizzo dell'ampiezza di banda della rete, nelle linee guida di Apple per le applicazioni iOS e Mac è specificato che solo i file che contengono dati immessi dall'utente o che non possono essere rigenerati o scaricati nuovamente dovrebbero essere sottoposti a backup.

Per impostazione predefinita, tutti i file nelle cartelle delle librerie dell'applicazione sono sottoposti a backup. In Mac OS X si tratta della directory di archiviazione dell'applicazione. In iOS, include la directory di archiviazione dell'applicazione, la directory dell'applicazione, la directory del desktop, la directory dei documenti e la directory utente (in quanto tali directory sono mappate per le cartelle delle librerie dell'applicazione in iOS). Di conseguenza, qualsiasi file contenuto in tali directory viene sottoposto a backup nello spazio di archiviazione del server per impostazione predefinita.

Se in una di queste posizioni state salvando un file che può essere ricreato dall'applicazione, si consiglia di contrassegnare il file in modo che il sistema operativo non lo sottoponga a backup. Per indicare che un file non deve essere sottoposto a backup, impostate la proprietà preventBackup dell'oggetto del File su true.

Considerate che nei dispositivi iOS, per un file in una qualsiasi cartella delle librerie dell'applicazione, anche se la proprietà preventBackup del file è impostata su true, il file è contrassegnato come persistente e pertanto non può essere eliminato dal sistema operativo.

Controllo dell'eliminazione e della memorizzazione del file

Nelle linee guida Apple per le applicazioni iOS è specificato che, per quanto possibile, il sistema operativo dovrebbe essere in grado di eliminare i contenuti che è possibile rigenerare, nel caso in cui lo spazio di archiviazione del dispositivo sia ridotto.

Nei dispositivi iOS, i file nelle cartelle delle librerie dell'applicazione (come la directory di archiviazione dell'applicazione o la directory dei documenti) sono contrassegnati come permanenti e non possono essere eliminati dal sistema operativo.

Salvate i file che possono essere rigenerati dall'applicazione ed è possibile eliminare se lo spazio di archiviazione della directory della cache dell'applicazione è ridotto. Potete accedere alla directory della cache mediante la proprietà statica File.cacheDirectory.

Nei dispositivi iOS, la directory della cache corrisponde alla directory della cache dell'applicazione (<Home applicazione>/Library/Caches). In altri sistemi operativi, la directory è mappata in una directory simile. Ad esempio, in Mac OS X viene inoltre mappata nella directory Cache nelle librerie dell'applicazione. In Android, la directory della cache viene mappata nella directory della cache dell'applicazione. In Windows, la directory della cache viene mappata nella directory temporanea del sistema operativo. In Android e Windows, si tratta della stessa directory a cui si accede mediante una chiamata ai metodi createTempDirectory() e createTempFile() della classe File.

Individuazione del percorso relativo tra due file

Potete utilizzare il metodo getRelativePath() per individuare il percorso relativo tra due file:

var file1:File = File.documentsDirectory.resolvePath("AIR Test"); 
var file2:File = File.documentsDirectory 
file2 = file2.resolvePath("AIR Test/bob/test.txt"); 
 
trace(file1.getRelativePath(file2)); // bob/test.txt 

Il secondo parametro del metodo getRelativePath(), il parametro useDotDot, consente di restituire la sintassi .. nei risultati, per indicare le directory principali:

var file1:File = File.documentsDirectory; 
file1 = file1.resolvePath("AIR Test"); 
var file2:File = File.documentsDirectory; 
file2 = file2.resolvePath("AIR Test/bob/test.txt"); 
var file3:File = File.documentsDirectory; 
file3 = file3.resolvePath("AIR Test/susan/test.txt"); 
 
trace(file2.getRelativePath(file1, true)); // ../.. 
trace(file3.getRelativePath(file2, true)); // ../../bob/test.txt 

Recupero di versioni canoniche dei nomi di file

Per i nomi di file e percorsi non viene fata distinzione tra maiuscole e minuscole in Windows e Mac OS. Nel caso seguente, due oggetti File puntano allo stesso file:

File.documentsDirectory.resolvePath("test.txt"); 
File.documentsDirectory.resolvePath("TeSt.TxT");

Tuttavia, i nomi dei documenti e delle directory includono caratteri sia minuscoli che maiuscoli. Ad esempio, il caso seguente ipotizza che vi sia una cartella denominata AIR Test nella directory documents:

var file:File = File.documentsDirectory.resolvePath("AIR test"); 
trace(file.nativePath); // ... AIR test 
file.canonicalize(); 
trace(file.nativePath); // ... AIR Test 

Il metodo canonicalize converte l'oggetto nativePath in modo che utilizzi le maiuscole corrette per il nome del file o della directory. Nei file system che fanno distinzione tra maiuscole e minuscole (ad esempio Linux), quando sono presenti più file con nomi diversi solo per le maiuscole/minuscole, il metodo canonicalize() adatta il percorso in modo che corrisponda al primo file trovato (in un ordine determinato dal file system).

Potete utilizzare il metodo canonicalize() anche per convertire i nomi file brevi (in formato "8.3") in nomi lunghi in Windows, come negli esempi seguenti:

var path:File = new File(); 
path.nativePath = "C:\\AIR~1"; 
path.canonicalize(); 
trace(path.nativePath); // C:\AIR Test

Operazioni con pacchetti e collegamenti simbolici

Diversi sistemi operativi supportano file di pacchetto e file di collegamenti simbolici:

Pacchetti - In Mac OS, le directory possono essere designate come pacchetti in modo da essere visualizzate nel Finder di Mac OS come file singolo anziché come directory.

Collegamenti simbolici - Mac OS, Linux e Windows Vista supportano i collegamenti simbolici. I collegamenti simbolici consentono a un file di puntare a un altro file o un'altra directory presente nel disco. Sebbene simili, i collegamenti simbolici non sono identici agli alias. Un alias è sempre indicato come file (anziché come directory) e la lettura o la scrittura di un alias o un collegamento a un alias non ha mai alcun effetto sul file o sulla directory originale a cui punta. Al contrario, un collegamento simbolico si comporta esattamente come il file o la directory a cui punta. Può essere indicato come file o directory e la lettura o la scrittura di un collegamento simbolico ha effetto sul file o sulla directory a cui punta, non sul collegamento simbolico. Inoltre, in Windows la proprietà isSymbolicLink per un oggetto File che fa riferimento a un punto di congiunzione (utilizzato nel file system NTFS) è impostata su true.

La classe File comprende le proprietà isPackage e isSymbolicLink, che consentono di verificare se un oggetto File fa riferimento a un pacchetto o a un collegamento simbolico.

Il codice seguente esegue un'iterazione nella directory desktop dell'utente, elencando le sottodirectory che non sono pacchetti:

var desktopNodes:Array = File.desktopDirectory.getDirectoryListing(); 
for (var i:uint = 0; i < desktopNodes.length; i++)  
{ 
    if (desktopNodes[i].isDirectory && !desktopNodes[i].isPackage) 
    { 
        trace(desktopNodes[i].name); 
    } 
} 

Il codice seguente esegue un'iterazione nella directory desktop dell'utente, elencando i file e le directory che non sono collegamenti simbolici:

var desktopNodes:Array = File.desktopDirectory.getDirectoryListing(); 
for (var i:uint = 0; i < desktopNodes.length; i++)  
{ 
    if (!desktopNodes[i].isSymbolicLink) 
    { 
        trace(desktopNodes[i].name); 
    } 
} 

Il metodo canonicalize() cambia il percorso di un collegamento simbolico in modo che punti al file o alla directory a cui il collegamento fa riferimento. Il codice seguente esegue un'iterazione nella directory desktop dell'utente e restituisce i percorsi a cui fanno riferimento i file che sono collegamenti simbolici:

var desktopNodes:Array = File.desktopDirectory.getDirectoryListing(); 
for (var i:uint = 0; i < desktopNodes.length; i++)  
{ 
    if (desktopNodes[i].isSymbolicLink) 
    { 
        var linkNode:File = desktopNodes[i] as File; 
        linkNode.canonicalize(); 
        trace(linkNode.nativePath); 
    } 
} 

Rilevamento dello spazio disponibile su un volume

La proprietà spaceAvailable di un oggetto File corrisponde allo spazio disponibile in byte per l'utilizzo nel percorso File. Ad esempio, il codice seguente controlla lo spazio disponibile nella directory di memorizzazione dell'applicazione:

trace(File.applicationStorageDirectory.spaceAvailable); 

Se l'oggetto File fa riferimento a una directory, la proprietà spaceAvailable indica lo spazio nella directory che i file possono utilizzare. Se l'oggetto File fa riferimento a un file, la proprietà spaceAvailable indica lo spazio in cui il file potrebbe aumentare di dimensione. Se il percorso del file non esiste, la proprietà spaceAvailable è impostata su 0. Se l'oggetto File fa riferimento a un collegamento simbolico, la proprietà spaceAvailable è impostata sullo spazio disponibile nel percorso a cui punta il collegamento simbolico.

Di solito lo spazio disponibile per una directory o un file è uguale allo spazio disponibile nel volume contenente la directory o il file. Tuttavia, tale spazio può includere quote e limiti per singola directory.

L'aggiunta di un file o di una directory a un volume di solito richiede più spazio delle dimensioni effettive del file o del contenuto della directory. Ad esempio, il sistema operativo può richiedere più spazio per memorizzare le informazioni di indice, oppure i settori del disco richiesti possono utilizzare altro spazio. Inoltre, lo spazio disponibile cambia in modo dinamico, quindi non è possibile prevedere di allocare tutto lo spazio indicato per la memorizzazione dei file. Per informazioni sulla scrittura nel file system, consultate Lettura e scrittura di file.

Il metodo StorageVolumeInfo.getStorageVolumes() fornisce informazioni più dettagliate sui volumi di memorizzazione montati (vedete Operazioni con volumi di memorizzazione).

Apertura di file con l'applicazione di sistema predefinita

In AIR 2, potete aprire un file utilizzando l'applicazione registrata dal sistema operativo per aprirla. Ad esempio, un'applicazione AIR può aprire un file DOC con l'applicazione registrata per aprirla. Utilizzate il metodo openWithDefaultApplication() di un oggetto File per aprire il file. Ad esempio, il codice seguente apre un file denominato test.doc sul desktop dell'utente utilizzando l'applicazione predefinita per i file DOC:

var file:File = File.deskopDirectory; 
file = file.resolvePath("test.doc"); 
file.openWithDefaultApplication();
Nota: in Linux, il tipo MIME del file, non l'estensione del nome file, determina l'applicazione predefinita per un file.

Il codice seguente consente all'utente di accedere a un file mp3 e di aprirlo nell'applicazione predefinita per la riproduzione di file mp3:

var file:File = File.documentsDirectory; 
var mp3Filter:FileFilter = new FileFilter("MP3 Files", "*.mp3"); 
file.browseForOpen("Open", [mp3Filter]); 
file.addEventListener(Event.SELECT, fileSelected); 
 
function fileSelected(e:Event):void 
{ 
    file.openWithDefaultApplication(); 
}

Non potete utilizzare il metodo openWithDefaultApplication() con file che si trovano nella directory dell'applicazione.

AIR impedisce di usare il metodo openWithDefaultApplication() per aprire alcuni file. In Windows, AIR impedisce di aprire file di un determinato tipo, ad esempio EXE o BAT. In Mac OS e Linux, AIR impedisce l'apertura di file che vengono avviati in un'applicazione specifica. (Questo include Terminal e AppletLauncher in Mac OS e csh, bash o ruby in Linux.) Se tentate di aprire uno di questi file utilizzando il metodo openWithDefaultApplication() viene generata un'eccezione. Per un elenco completo dei tipi di file non consentiti, vedete la voce della Guida di riferimento per il metodo File.openWithDefaultApplication().

Nota: questa limitazione non esiste per un'applicazione AIR installata utilizzando un programma di installazione nativo (un'applicazione desktop estesa).