Trabajo con objetos File en AIR

La clase File se emplea para lo siguiente:

• obtener la ruta a directorios especiales, entre ellos el directorio del usuario, el directorio de documentos del usuario, el directorio desde el cual se inició la aplicación, y el directorio de la aplicación;

• copiar archivos y directorios;

• mover archivos y directorios;

• eliminar archivos y directorios (o pasarlos a la papelera);

• enumerar los archivos y directorios que contiene un directorio;

• crear archivos y directorios temporales.

Una vez que un objeto File apunta a una ruta de archivo, se puede utilizar para leer y escribir datos de archivo usando la clase FileStream.

Un objeto File puede apuntar a la ruta de un archivo o directorio que aún no existe. Puede utilizarse un objeto File de este tipo al crear un archivo o directorio.

Cada objeto File tiene dos propiedades que definen su ruta:

La clase File incluye propiedades estáticas para señalar a directorios estándar tanto en Mac OS, Windows y Linux. Entre estas propiedades se incluyen:

Estas propiedades tienen valores diferentes en los distintos sistemas operativos. Por ejemplo, Mac y Windows cuentan con rutas nativas distintas en el directorio del escritorio del usuario. Sin embargo, la propiedad File.desktopDirectory señala a una ruta de directorio adecuada en todas las plataformas. Para escribir aplicaciones que funcionen bien en distintas plataformas, utilice estas propiedades como base para hacer referencia a otros directorios y archivos utilizados por la aplicación. Utilice el método resolvePath() para mejorar la ruta. Por ejemplo, el siguiente código señala al archivo preferences.xml en el directorio de almacenamiento de la aplicación:

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

Aunque la clase File permite señalar a una ruta de archivo específica, esto puede implicar que las aplicaciones no funcionen en distintas plataformas. Por ejemplo, la ruta C:\Documents and Settings\joe\ solo funciona en Windows. Por estos motivos, es mejor utilizar las propiedades estáticas de la clase File como, por ejemplo, File.documentsDirectory .

Las rutas nativas reales para estos directorios varían en función del sistema operativo y la configuración del equipo. Las rutas que se muestran en esta tabla representan ejemplos típicos. Siempre se deben utilizar las propiedades estáticas adecuadas de la clase File para hacer referencia a estos directorios de forma que la aplicación funcione correctamente en cualquier plataforma. En una aplicación real de AIR, los valores para applicationID y filename mostrados en la tabla proceden del descriptor de la aplicación. Si se especifica un ID de editor en el descriptor de la aplicación, este ID se añade al ID de la aplicación en estas rutas. El valor de userName es el nombre de la cuenta del usuario que realiza la instalación.

Existen distintas formas de configurar un objeto File para que apunte a un directorio.

Existen distintas formas de configurar el archivo al que apunta un objeto File.

Se puede también modificar la ruta de un objeto File existente llamando al método resolvePath() o modificando la propiedad nativePath o url del objeto, como en los ejemplos siguientes (en 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 

Al usar la propiedad nativePath , utilice el carácter de barra diagonal (/) como carácter separador de directorios. En Windows, también se puede emplear el carácter de barra diagonal inversa (\), pero no es recomendable, ya que implica que el código no funcione en distintas plataformas.

En AIR, Al definir la propiedad url de un objeto File se puede utilizar cualquiera de los esquemas de URL siguientes:

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

app:/images

app-storage:/settings/prefs.xml

En ciertos sistemas operativos, especialmente iOS y Mac OS X, se pueden crear automáticamente copias de seguridad de archivos de aplicación en un almacenamiento remoto. Además, en iOS existen restricciones de copia de seguridad aplicables de algunos archivos, así como restricciones sobre la ubicación en la que guardar archivos según su finalidad.

A continuación se resumen las directrices de Apple sobre copia de seguridad y almacenamiento. En secciones posteriores encontrará más información al respecto.

• Para especificar que no se requiere una copia de seguridad de un archivo y (solo iOS) que el sistema operativo puede eliminarlo si hace falta liberar espacio de almacenamiento en el dispositivo, guarde el archivo en el directorio de memoria caché ( File.cacheDirectory ). Esta es la ubicación preferida en iOS y debería utilizarse para la mayoría de archivos que pueden volver a generarse o cargarse.

• Para especificar que no se requiere una copia de seguridad de un archivo pero el sistema operativo no debería eliminarlo, guárdelo en uno de los directorios de bibliotecas de la aplicación (por ejemplo, File.applicationStorageDirectory ) o en el directorio de documentos ( File.documentsDirectory ). Establezca la propiedad de objeto File preventBackup en true . Apple lo exige así para contenido que puede volver a generarse o cargarse y es necesario para el funcionamiento correcto de la aplicación cuando se usa sin conexión.

El método getRelativePath() sirve para buscar la ruta relativa entre dos archivos:

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 

El segundo parámetro del método getRelativePath() , el parámetro useDotDot , permite que se incluya la sintaxis .. en los resultados para indicar directorios superiores:

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 

En los nombres de ruta y archivo no se distingue entre mayúsculas y minúsculas en Windows y Mac OS. En el siguiente ejemplo, dos objetos File apuntan al mismo archivo:

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

No obstante, los documentos y nombres de directorio sí incluyen mayúsculas. En los siguientes ejemplos se da por sentado que existe una carpeta llamada AIR Test en el directorio de documentos:

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

El método canonicalize() convierte el objeto nativePath para que figuren correctamente las mayúsculas en el nombre del archivo o directorio. En los sistemas de archivos que distinguen entre mayúsculas y minúsculas (como Linux), cuando existen varios archivos con nombres que difieren únicamente en las mayúsculas y minúsculas, el método canonicalize() ajusta la ruta para que coincida con el primer archivo encontrado (en un orden que determina el sistema de archivos).

El método canonicalize() también sirve para convertir nombres de archivo cortos (nombres "8.3") en nombres de archivo largos en Windows, como en los ejemplos siguientes:

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

Diversos sistemas operativos admiten archivos de paquetes y archivos de vínculos simbólicos:

Paquetes En Mac OS, los directorios pueden designarse como paquetes y aparecer en el Finder de Mac OS archivo sencillo en lugar de como directorio.

Vínculos simbólicos Mac OS, Linux y Windows Vista admiten este tipo de vínculos. Los vínculos simbólicos permiten que un archivo apunte a otro archivo o directorio del disco. Si bien son similares, los vínculos simbólicos no son lo mismo que los alias. Un alias siempre se notifica como archivo (y no como directorio) y la lectura o escritura en un alias o acceso directo no afecta nunca el archivo o directorio original al que apunta. Por otro lado, un vínculo simbólico se comporta exactamente igual que el archivo o directorio al que apunta. Se puede notificar como archivo o directorio, y la lectura o escritura en un vínculo simbólico afecta al archivo o directorio al que apunta y no al propio vínculo simbólico. Asimismo, en Windows la propiedad isSymbolicLink para un objeto File que hace referencia a un punto de unión (utilizado en el sistema de archivos NTFS) se establece en true .

La clase File incluye las propiedades isPackage y isSymbolicLink para comprobar si un objeto File remite a un paquete o a un vínculo simbólico.

El código siguiente itera a través del directorio del escritorio del usuario, enumerando los subdirectorios que no son paquetes:

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

El código siguiente itera a través del directorio del escritorio del usuario, enumerando los archivos y directorios que no son vínculos simbólicos:

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

El método canonicalize() modifica la ruta de un vínculo simbólico para apuntar al archivo o directorio al que se refiere el vínculo. El código siguiente itera a través del directorio del escritorio del usuario y notifica las rutas referenciadas por archivos que son vínculos simbólicos:

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 propiedad spaceAvailable de un objeto File es el espacio (expresado en bytes) que está disponible para ser utilizado en el lugar donde se encuentra el archivo. Por ejemplo, el código siguiente comprueba el espacio disponible en el directorio de almacenamiento de la aplicación:

trace(File.applicationStorageDirectory.spaceAvailable); 

Si el objeto File remite a un directorio, la propiedad spaceAvailable indica el espacio en el directorio que utilizan los archivos. Si el objeto File remite a un archivo, la propiedad spaceAvailable indica el espacio en el que podría ampliarse el archivo. Si no existe la ubicación de archivo, la propiedad spaceAvailable se define en 0. Si el objeto File remite a un vínculo simbólico, la propiedad spaceAvailable se define en el espacio disponible en el lugar al que apunta el vínculo simbólico.

El espacio disponible para un directorio o archivo suele ser el mismo que el que está disponible en el volumen que contiene el directorio o el archivo. No obstante, el espacio disponible puede ajustarse teniendo en cuenta los cupos y límites por directorio.

Para añadir un archivo o directorio a un volumen se suele necesitar más espacio que el tamaño mismo del archivo o del contenido del directorio. Por ejemplo, el sistema operativo puede necesitar más espacio para guardar la información del índice. O los sectores del disco que se requieren pueden usar espacio adicional. Además, el espacio que hay disponible cambia constantemente. Por todo ello es que no se puede asignar todo el espacio notificado a guardar los archivos. Para ver más información sobre la escritura en el sistema de archivos, consulte Lectura y escritura de archivos .

El método StorageVolumeInfo.getStorageVolumes() proporciona más información detallada sobre los volúmenes de almacenamiento montados (consulte Trabajo con volúmenes de almacenamiento ).

En AIR 2, es posible abrir un archivo utilizando la aplicación registrada por el sistema operativo para abrirla. Por ejemplo, una aplicación de AIR puede abrir un archivo DOC con la aplicación resgitrada para abrirlo. Utilice el método openWithDefaultApplication() de un objeto File para abrir el archivo. Por ejemplo, el siguiente código abre un archivo denominado test.doc en el escritorio del usuario y lo abre con la aplicación predeterminada para los archivos DOC:

var file:File = File.deskopDirectory; 
file = file.resolvePath("test.doc"); 
file.openWithDefaultApplication();

El siguiente código permite al usuario buscar un archivo mp3 y abrirlo en la aplicación predeterminada para reproducir archivos 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(); 
}

El método openWithDefaultApplication() no se puede utilizar con archivos ubicados en el directorio de la aplicación.

AIR impide el uso del método openWithDefaultApplication() para abrir determinados archivos. En Windows, AIR impide la apertura de archivos de determinados tipos como, por ejemplo, EXE o BAT. En Mac OS y en Linux, AIR impide abrir archivos que inician una aplicación específica. (Estos incluyen Terminal y AppletLauncher en Mac OS; y csh, bash o ruby en Linux.) Si se intenta abrir uno de estos archivos con el método openWithDefaultApplication() , se generará una excepción. Para obtener una lista de los tipos de archivo con limitaciones, consulte la entrada de la referencia del lenguaje del método File.openWithDefaultApplication() .