Operazioni con oggetti File in AIR

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.

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

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

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 .

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.

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

Sono disponibili diversi modi per impostare il file a cui punta un oggetto 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.

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

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

app:/images

app-storage:/settings/prefs.xml

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.

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 

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

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); 
    } 
} 

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 ).

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();

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() .