Uso de la clase FileReference

Cada objeto FileReference representa un único archivo de datos del equipo. Las propiedades de la clase FileReference contienen la siguiente información referente al archivo: tamaño, tipo, nombre, extensión, creador, fecha de creación y fecha de modificación.

Se puede crear una instancia de la clase FileReference de una de estas dos formas:

• Con el operador new , como se puede ver en el siguiente código:

  import flash.net.FileReference; 
  var fileRef:FileReference = new FileReference();

• Llame al método FileReferenceList.browse() , que abre un cuadro de diálogo y solicita al usuario que seleccione uno o varios archivos para cargar. Seguidamente, crea un conjunto de objetos FileReference si el usuario selecciona correctamente uno o varios archivos.

Una vez creado el objeto FileReference, puede realizar lo siguiente:

• Llamar al método FileReference.browse() , que abre un cuadro de diálogo y solicita al usuario que seleccione un solo archivo del sistema de archivos locales. Esto se suele realizar antes de una llamada posterior al método FileReference.upload() o FileReference.load() . Llame al método FileReference.upload() para cargar el archivo en un servidor remoto. Llame al método FileReference.load() para abrir un archivo local.

• Llamada al método FileReference.download() . El método download() abre un cuadro de diálogo donde el usuario puede seleccionar una ubicación para guardar el nuevo archivo. Posteriormente, descarga datos del servidor y los guarda en el nuevo archivo.

• Llamada al método FileReference.load() . Este método comienza a cargar datos desde un archivo seleccionado previamente mediante el método browse() . No es posible llamar al método load() hasta que no finaliza la operación de browse() (el usuario selecciona un archivo).

• Llamada al método FileReference.save() . Este método abre un cuadro de diálogo y pide al usuario que seleccione una ubicación de archivo única en el sistema de archivos local. Seguidamente, guarda los datos en la ubicación especificada.

Las propiedades del objeto FileReference, como name , size o modificationDate no se definen hasta que se produce una de las situaciones siguientes:

• Se ha llamado al método FileReference.browse() o FileReferenceList.browse() y el usuario ha seleccionado un archivo desde el cuadro de diálogo.

• Se ha llamado al método FileReference.download() y el usuario ha especificado una nueva ubicación del archivo desde el cuadro de diálogo.

Durante la llamada a los métodos FileReference.browse() , FileReferenceList.browse() , FileReference.download() , FileReference.load() o FileReference.save() , la mayoría de reproductores continúan ejecutando el archivo SWF, incluidas la distribución de eventos y la ejecución del código.

Para las operaciones de carga y descarga, un archivo SWF solo puede acceder a archivos de su propio dominio, incluidos los dominios especificados en un archivo de política. Es preciso colocar un archivo de política en el servidor que contiene el archivo si dicho servidor no se encuentra en el mismo dominio que el archivo SWF que inicia la carga o la descarga.

Consulte FileReference .

El método FileReference.load() permite cargar datos en la memoria local desde un archivo local.

El método FileReference.load() devuelve un valor inmediatamente después de la llamada, pero los datos que se cargan no están disponibles hasta un tiempo después. El objeto FileReference distribuye eventos para invocar métodos de detectores en cada paso del proceso de carga.

El objeto FileReference distribuye los siguientes eventos durante el proceso de carga.

• Evento open ( Event.OPEN ): se distribuye cuando se inicia la operación de carga.

• Evento progress ( ProgressEvent.PROGRESS ): se distribuye periódicamente a medida que se leen bytes de datos del archivo.

• Evento complete ( Event.COMPLETE ): se distribuye cuando la operación de carga finaliza correctamente.

• Evento ioError ( IOErrorEvent.IO_ERROR ): se distribuye si falla el proceso de carga debido a un error de entrada/salida durante la apertura o la lectura de los datos en el archivo.

Cuando el objeto FileReference distribuye el evento complete, es posible acceder a los datos cargados como un elemento ByteArray en la propiedad data del objeto FileReference.

El siguiente ejemplo muestra cómo solicitar al usuario que seleccione un archivo y cargue en la memoria los datos de dicho archivo:

package 
{ 
     import flash.display.Sprite; 
    import flash.events.*;  
    import flash.net.FileFilter; 
    import flash.net.FileReference; 
    import flash.net.URLRequest; 
    import flash.utils.ByteArray; 
 
    public class FileReferenceExample1 extends Sprite 
    { 
        private var fileRef:FileReference; 
        public function FileReferenceExample1() 
        { 
            fileRef = new FileReference(); 
            fileRef.addEventListener(Event.SELECT, onFileSelected); 
            fileRef.addEventListener(Event.CANCEL, onCancel); 
            fileRef.addEventListener(IOErrorEvent.IO_ERROR, onIOError); 
            fileRef.addEventListener(SecurityErrorEvent.SECURITY_ERROR, 
                        onSecurityError); 
            var textTypeFilter:FileFilter = new FileFilter("Text Files (*.txt, *.rtf)", 
                        "*.txt;*.rtf"); 
            fileRef.browse([textTypeFilter]); 
        } 
        public function onFileSelected(evt:Event):void 
        { 
            fileRef.addEventListener(ProgressEvent.PROGRESS, onProgress); 
            fileRef.addEventListener(Event.COMPLETE, onComplete); 
            fileRef.load(); 
        } 
 
        public function onProgress(evt:ProgressEvent):void 
        { 
            trace("Loaded " + evt.bytesLoaded + " of " + evt.bytesTotal + " bytes."); 
        } 
 
        public function onComplete(evt:Event):void 
        { 
            trace("File was successfully loaded."); 
            trace(fileRef.data); 
        } 
 
        public function onCancel(evt:Event):void 
        { 
            trace("The browse request was canceled by the user."); 
        } 
 
        public function onIOError(evt:IOErrorEvent):void 
        { 
            trace("There was an IO Error."); 
        } 
        public function onSecurityError(evt:Event):void 
        { 
            trace("There was a security error."); 
        } 
    } 
}

El código de ejemplo primero crea el objeto FileReference llamado fileRef y, a continuación, llama a su método browse() . El método browse() abre un cuadro de diálogo que solicita al usuario que seleccione un archivo. Cuando un archivo está seleccionado, el código invoca al método onFileSelected() . Este método añade detectores para los eventos progress y complete y, seguidamente, llama al método load() del objeto FileReference. Los otros métodos de controladores del ejemplo simplemente producen mensajes que informan sobre el progreso de la operación de carga. Cuando finaliza la carga, la aplicación muestra el contenido del archivo cargado mediante el método trace() .

En Adobe AIR, la clase FileStream proporciona una funcionalidad adicional para leer datos desde un archivo local. Consulte Lectura y escritura de archivos .

El método FileReference.save() permite guardar datos en un archivo local. Comienza abriendo un cuadro de diálogo para que el usuario pueda introducir un nuevo nombre de archivo y una ubicación en la que guardarlo. Una vez seleccionado el nombre de archivo y la ubicación, los datos se escriben en el nuevo archivo. Una vez guardado correctamente el archivo, las propiedades del objeto FileReference se llenan con las propiedades del archivo local.

El método FileReference.save() devuelve un valor inmediatamente después de recibir la llamada. Seguidamente, el objeto FileReference distribuye eventos para llamar a métodos de detección en cada paso del proceso grabación del archivo.

El objeto FileReference distribuye los siguientes eventos durante el proceso de grabación del archivo:

• Evento select ( Event.SELECT ): se distribuye cuando el usuario especifica la ubicación y el nombre de archivo del nuevo archivo que se va a guardar.

• Evento cancel ( Event.CANCEL ): se distribuye cuando el usuario hace clic en el botón Cancelar del cuadro de diálogo.

• Evento open ( Event.OPEN ): se distribuye cuando se inicia la operación de grabación.

• Evento progress ( ProgressEvent.PROGRESS ): se distribuye periódicamente a medida que los bytes de datos se guardan en el archivo.

• Evento complete ( Event.COMPLETE ): se distribuye cuando la operación de grabación finaliza correctamente.

• Evento ioError ( IOErrorEvent.IO_ERROR ): se distribuye si el proceso de grabación falla debido a un error de entrada/salida al intentar guardar los datos en el archivo.

El tipo de objeto transferido en el parámetro data del método FileReference.save() determina el modo en el que se escriben los datos en el archivo:

• Si es un valor String, se guarda como un archivo de texto con codificación UTF-8.

• Si es un objeto XML, se escribe en un archivo en formato XML (conservando todo el formato).

• Si es un objeto Array, su contenido se escribe directamente en el archivo sin conversión alguna.

• Si es cualquier otro objeto, el método FileReference.save() llama al método toString() del objeto y guarda el valor String resultante en un archivo de texto UTF-8. Si no se puede llamar al método toString() del objeto, se emite un error.

Si el valor del parámetro data es null , se genera un error.

El siguiente código amplía el ejemplo anterior para el método FileReference.load() . Una vez leídos los datos del archivo, este ejemplo solicita al usuario que especifique un nombre de archivo y, a continuación, guarda los datos en un nuevo archivo:

package 
{ 
    import flash.display.Sprite; 
    import flash.events.*;  
    import flash.net.FileFilter; 
    import flash.net.FileReference; 
    import flash.net.URLRequest; 
    import flash.utils.ByteArray; 
 
    public class FileReferenceExample2 extends Sprite 
    { 
        private var fileRef:FileReference; 
        public function FileReferenceExample2() 
        { 
            fileRef = new FileReference(); 
            fileRef.addEventListener(Event.SELECT, onFileSelected); 
            fileRef.addEventListener(Event.CANCEL, onCancel); 
            fileRef.addEventListener(IOErrorEvent.IO_ERROR, onIOError); 
            fileRef.addEventListener(SecurityErrorEvent.SECURITY_ERROR, 
                        onSecurityError); 
            var textTypeFilter:FileFilter = new FileFilter("Text Files (*.txt, *.rtf)", 
                        "*.txt;*.rtf"); 
            fileRef.browse([textTypeFilter]); 
        } 
        public function onFileSelected(evt:Event):void 
        { 
            fileRef.addEventListener(ProgressEvent.PROGRESS, onProgress); 
            fileRef.addEventListener(Event.COMPLETE, onComplete); 
            fileRef.load(); 
        } 
 
        public function onProgress(evt:ProgressEvent):void 
        { 
            trace("Loaded " + evt.bytesLoaded + " of " + evt.bytesTotal + " bytes."); 
        } 
        public function onCancel(evt:Event):void 
        { 
            trace("The browse request was canceled by the user."); 
        } 
        public function onComplete(evt:Event):void 
        { 
            trace("File was successfully loaded."); 
            fileRef.removeEventListener(Event.SELECT, onFileSelected); 
            fileRef.removeEventListener(ProgressEvent.PROGRESS, onProgress); 
            fileRef.removeEventListener(Event.COMPLETE, onComplete); 
            fileRef.removeEventListener(Event.CANCEL, onCancel); 
            saveFile(); 
        } 
        public function saveFile():void 
        { 
            fileRef.addEventListener(Event.SELECT, onSaveFileSelected); 
            fileRef.save(fileRef.data,"NewFileName.txt"); 
        } 
 
        public function onSaveFileSelected(evt:Event):void 
        { 
            fileRef.addEventListener(ProgressEvent.PROGRESS, onSaveProgress); 
            fileRef.addEventListener(Event.COMPLETE, onSaveComplete); 
            fileRef.addEventListener(Event.CANCEL, onSaveCancel); 
        } 
 
        public function onSaveProgress(evt:ProgressEvent):void 
        { 
            trace("Saved " + evt.bytesLoaded + " of " + evt.bytesTotal + " bytes."); 
        } 
         
        public function onSaveComplete(evt:Event):void 
        { 
            trace("File saved."); 
            fileRef.removeEventListener(Event.SELECT, onSaveFileSelected); 
            fileRef.removeEventListener(ProgressEvent.PROGRESS, onSaveProgress); 
            fileRef.removeEventListener(Event.COMPLETE, onSaveComplete); 
            fileRef.removeEventListener(Event.CANCEL, onSaveCancel); 
        } 
 
        public function onSaveCancel(evt:Event):void 
        { 
            trace("The save request was canceled by the user."); 
        } 
 
        public function onIOError(evt:IOErrorEvent):void 
        { 
            trace("There was an IO Error."); 
        } 
        public function onSecurityError(evt:Event):void 
        { 
            trace("There was a security error."); 
        } 
    } 
}

Si todos los datos se cargan desde el archivo, el código llama al método onComplete() . El método onComplete() elimina los detectores de los eventos de carga y seguidamente llama al método saveFile() . El método saveFile() llama a FileReference.save() . El método FileReference.save() abre un nuevo cuadro de diálogo para que el usuario pueda indicar un nuevo nombre de archivo y ubicación para guardarlo. Los métodos de detectores de eventos restantes realizan el seguimiento del progreso de grabación del archivo hasta que finaliza.

En Adobe AIR, la clase FileStream proporciona funcionalidad adicional para escribir datos en un archivo local. Consulte Lectura y escritura de archivos .

Para cargar archivos en un servidor, hay que llamar primero al método browse() para permitir que un usuario seleccione uno o varios archivos. A continuación, cuando se llama al método FileReference.upload() , el archivo seleccionado se transfiere al servidor. Si el usuario ha seleccionado varios archivos con el método FileReferenceList.browse() , Flash Player crea un conjunto de archivos seleccionados denominado FileReferenceList.fileList . A continuación, se puede utilizar el método FileReference.upload() para cargar cada archivo de forma individual.

De forma predeterminada, el cuadro de diálogo del selector de archivos del sistema permite a los usuarios seleccionar cualquier tipo de archivo del equipo local, aunque los desarrolladores pueden especificar uno o varios filtros personalizados de tipo de archivo. Para ello, deben utilizar la clase FileFilter y pasar un conjunto de instancias de filtro de archivos al método browse() :

var imageTypes:FileFilter = new FileFilter("Images (*.jpg, *.jpeg, *.gif, *.png)", "*.jpg; *.jpeg; *.gif; *.png"); 
var textTypes:FileFilter = new FileFilter("Text Files (*.txt, *.rtf)", "*.txt; *.rtf"); 
var allTypes:Array = new Array(imageTypes, textTypes); 
var fileRef:FileReference = new FileReference(); 
fileRef.browse(allTypes);

Cuando el usuario ha seleccionado los archivos y ha hecho clic en el botón Abrir en el selector de archivos del sistema, se distribuye el evento Event.SELECT . Si se ha utilizado el método FileReference.browse() para seleccionar un archivo para cargarlo, es necesario utilizar el siguiente código para enviar el archivo a un servidor web:

var fileRef:FileReference = new FileReference(); 
fileRef.addEventListener(Event.SELECT, selectHandler); 
fileRef.addEventListener(Event.COMPLETE, completeHandler); 
try 
{ 
    var success:Boolean = fileRef.browse(); 
} 
catch (error:Error) 
{ 
    trace("Unable to browse for files."); 
} 
function selectHandler(event:Event):void 
{ 
    var request:URLRequest = new URLRequest("http://www.[yourdomain].com/fileUploadScript.cfm") 
    try 
    { 
        fileRef.upload(request); 
    } 
    catch (error:Error) 
    { 
        trace("Unable to upload file."); 
    } 
} 
function completeHandler(event:Event):void 
{ 
    trace("uploaded"); 
}

Para enviar datos al servidor con el método FileReference.upload() , se pueden utilizar las propiedades URLRequest.method y URLRequest.data para enviar variables con los métodos POST o GET .

Cuando se intenta cargar un archivo con el método FileReference.upload() , se pueden distribuir los siguientes eventos:

• Evento open ( Event.OPEN ): se distribuye cuando se inicia la operación de carga.

• Evento progress ( ProgressEvent.PROGRESS ): se distribuye periódicamente a medida que se cargan los bytes de datos del archivo.

• Evento complete ( Event.COMPLETE ): se distribuye cuando la operación de carga finaliza correctamente.

• Evento httpStatus ( HTTPStatusEvent.HTTP_STATUS ): se distribuye cuando el proceso de carga falla debido a un error HTTP.

• Evento httpResponseStatus ( HTTPStatusEvent.HTTP_RESPONSE_STATUS ): se distribuye si una llamada a los métodos upload() o uploadUnencoded() intenta acceder a los datos mediante HTTP y Adobe AIR puede detectar y devolver el código de estado de la petición.

• Evento securityError ( SecurityErrorEvent.SECURITY_ERROR ): se distribuye cuando se produce un error en la carga debido a una infracción de la seguridad.

• Evento uploadCompleteData ( DataEvent.UPLOAD_COMPLETE_DATA ): se distribuye cuando se han recibido datos del servidor tras una carga correcta.

• Evento ioError ( IOErrorEvent.IO_ERROR ): se distribuye si falla el proceso de carga por cualquiera de los siguientes motivos:

  • Se produce un error de entrada/salida mientras Flash Player lee, escribe o transmite el archivo.

  • El archivo SWF intenta cargar un archivo en un servidor que requiere autenticación, por ejemplo, un nombre de usuario y una contraseña. Durante la carga, Flash Player no proporciona un medio para que los usuarios introduzcan contraseñas.

  • El parámetro url contiene un protocolo no válido. El método FileReference.upload() debe utilizar HTTP o HTTPS.

Flash Player no ofrece compatibilidad total con los servidores que requieren autenticación. Únicamente los archivos SWF que se ejecutan en un navegador y emplean el plugin de navegador o un control Microsoft ActiveX®, pueden mostrar un cuadro de diálogo que indique al usuario que introduzca un nombre de usuario y una contraseña para la autenticación y, además, solo para descargas. La transferencia de archivos no se producirá correctamente en las cargas que utilicen el plug-in o el control ActiveX, o en las cargas y descargas que utilicen el reproductor autónomo o externo.

Si se crea un script de servidor en ColdFusion para aceptar una carga de archivos desde Flash Player, se puede utilizar un código similar al siguiente:

<cffile action="upload" filefield="Filedata" destination="#ExpandPath('./')#" nameconflict="OVERWRITE" />

Este código de ColdFusion carga el archivo enviado por Flash Player y lo guarda en el mismo directorio que la plantilla de ColdFusion, sobrescribiendo cualquier archivo con el mismo nombre. El código anterior muestra la cantidad mínima de código necesario para aceptar una carga de archivos; este script no debería utilizarse en un entorno de producción. Lo ideal sería añadir validación de datos para garantizar que los usuarios solo cargan tipos de archivos aceptados como, por ejemplo, una imagen, en lugar de un script de servidor potencialmente peligroso.

El siguiente código muestra cargas de archivos mediante PHP e incluye validación de datos. El script limita en 10 el número de archivos cargados en el directorio de carga, garantiza que el tamaño de archivo es inferior a 200 KB, y solo permite cargar y guardar archivos JPEG, GIF o PNG en el sistema de archivos.

<?php 
$MAXIMUM_FILESIZE = 1024 * 200; // 200KB 
$MAXIMUM_FILE_COUNT = 10; // keep maximum 10 files on server 
echo exif_imagetype($_FILES['Filedata']); 
if ($_FILES['Filedata']['size'] <= $MAXIMUM_FILESIZE) 
{ 
    move_uploaded_file($_FILES['Filedata']['tmp_name'], "./temporary/".$_FILES['Filedata']['name']); 
    $type = exif_imagetype("./temporary/".$_FILES['Filedata']['name']); 
    if ($type == 1 || $type == 2 || $type == 3) 
    { 
        rename("./temporary/".$_FILES['Filedata']['name'], "./images/".$_FILES['Filedata']['name']); 
    } 
    else 
    { 
        unlink("./temporary/".$_FILES['Filedata']['name']); 
    } 
} 
$directory = opendir('./images/'); 
$files = array(); 
while ($file = readdir($directory)) 
{ 
    array_push($files, array('./images/'.$file, filectime('./images/'.$file))); 
} 
usort($files, sorter); 
if (count($files) > $MAXIMUM_FILE_COUNT) 
{ 
    $files_to_delete = array_splice($files, 0, count($files) - $MAXIMUM_FILE_COUNT); 
    for ($i = 0; $i < count($files_to_delete); $i++) 
    { 
        unlink($files_to_delete[$i][0]); 
    } 
} 
print_r($files); 
closedir($directory); 
 
function sorter($a, $b) 
{ 
    if ($a[1] == $b[1]) 
    { 
        return 0; 
    } 
    else 
    { 
        return ($a[1] < $b[1]) ? -1 : 1; 
    } 
} 
?>

Se pueden pasar variables adicionales al script de carga mediante el método de petición POST o GET . Para enviar variables adicionales de POST al script de carga, se puede utilizar el siguiente código:

var fileRef:FileReference = new FileReference(); 
fileRef.addEventListener(Event.SELECT, selectHandler); 
fileRef.addEventListener(Event.COMPLETE, completeHandler); 
fileRef.browse(); 
function selectHandler(event:Event):void 
{ 
    var params:URLVariables = new URLVariables(); 
    params.date = new Date(); 
    params.ssid = "94103-1394-2345"; 
    var request:URLRequest = new URLRequest("http://www.yourdomain.com/FileReferenceUpload/fileupload.cfm"); 
    request.method = URLRequestMethod.POST; 
    request.data = params; 
    fileRef.upload(request, "Custom1"); 
} 
function completeHandler(event:Event):void 
{ 
    trace("uploaded"); 
}

El ejemplo anterior crea un objeto URLVariables que se transmite al script del servidor remoto. En versiones anteriores de ActionScript, se podían pasar variables al script de carga del servidor pasando valores en la cadena de consulta. ActionScript 3.0 permite pasar variables al script remoto con un objeto URLRequest, que permite pasar datos mediante el método POST o GET que, a su vez, hace más sencillo pasar grandes conjuntos de datos. Para especificar si las variables se pasan con el método de petición GET o POST , se puede establecer la propiedad URLRequest.method en URLRequestMethod.GET o URLRequestMethod.POST , respectivamente.

ActionScript 3.0 también permite sustituir el nombre del campo de archivo de carga predeterminado, Filedata , proporcionando un segundo parámetro al método upload() , como se muestra en el ejemplo anterior (que sustituía el valor predeterminado Filedata por Custom1 ).

De forma predeterminada, Flash Player no intentará enviar una carga de prueba, aunque este valor predeterminado se puede omitir pasando un valor de true como tercer parámetro al método upload() . El objetivo de la carga de prueba es comprobar si la carga de archivos real se realizará correctamente, así como la autenticación del servidor, en caso de ser necesaria.

El script de servidor que gestiona la carga de archivos espera una petición HTTP POST con los siguientes elementos:

• Content-Type con un valor multipart/form-data .

• Content-Disposition con un atributo name establecido en " Filedata " y un atributo filename establecido en el nombre del archivo original. Se puede especificar un atributo name personalizado pasando un valor para el parámetro uploadDataFieldName en el método FileReference.upload() .

• El contenido binario del archivo.

A continuación se muestra un ejemplo de petición HTTP POST :

POST /handler.asp HTTP/1.1 
Accept: text/* 
Content-Type: multipart/form-data; 
boundary=----------Ij5ae0ae0KM7GI3KM7ei4cH2ei4gL6 
User-Agent: Shockwave Flash 
Host: www.mydomain.com 
Content-Length: 421 
Connection: Keep-Alive 
Cache-Control: no-cache 
 
------------Ij5ae0ae0KM7GI3KM7ei4cH2ei4gL6  
Content-Disposition: form-data; name="Filename" 
 
sushi.jpg  
------------Ij5ae0ae0KM7GI3KM7ei4cH2ei4gL6 
Content-Disposition: form-data; name="Filedata"; filename="sushi.jpg" 
Content-Type: application/octet-stream 
 
Test File  
------------Ij5ae0ae0KM7GI3KM7ei4cH2ei4gL6 
Content-Disposition: form-data; name="Upload" 
 
Submit Query 
------------Ij5ae0ae0KM7GI3KM7ei4cH2ei4gL6 
(actual file data,,,)

La siguiente petición de ejemplo HTTP POST envía tres variables POST : api_sig , api_key y auth_token y utiliza un valor de nombre de campo de datos de carga personalizado de "photo" :

POST /handler.asp HTTP/1.1 
Accept: text/* 
Content-Type: multipart/form-data; 
boundary=----------Ij5ae0ae0KM7GI3KM7ei4cH2ei4gL6 
User-Agent: Shockwave Flash 
Host: www.mydomain.com 
Content-Length: 421 
Connection: Keep-Alive 
Cache-Control: no-cache 
 
------------Ij5GI3GI3ei4GI3ei4KM7GI3KM7KM7 
Content-Disposition: form-data; name="Filename" 
 
sushi.jpg 
------------Ij5GI3GI3ei4GI3ei4KM7GI3KM7KM7 
Content-Disposition: form-data; name="api_sig" 
 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
------------Ij5GI3GI3ei4GI3ei4KM7GI3KM7KM7 
Content-Disposition: form-data; name="api_key" 
 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
------------Ij5GI3GI3ei4GI3ei4KM7GI3KM7KM7 
Content-Disposition: form-data; name="auth_token" 
 
XXXXXXXXXXXXXXXXXXXXXXX 
------------Ij5GI3GI3ei4GI3ei4KM7GI3KM7KM7 
Content-Disposition: form-data; name="photo"; filename="sushi.jpg" 
Content-Type: application/octet-stream 
 
(actual file data,,,) 
------------Ij5GI3GI3ei4GI3ei4KM7GI3KM7KM7 
Content-Disposition: form-data; name="Upload" 
 
Submit Query 
------------Ij5GI3GI3ei4GI3ei4KM7GI3KM7KM7--

Para permitir que los usuarios descarguen archivos de un servidor, se utiliza el método FileReference.download() , que utiliza dos parámetros request y defaultFileName . El primer parámetro es el objeto URLRequest que contiene el URL del archivo para descargar. El segundo parámetro es opcional y permite especificar un nombre de archivo predeterminado que aparece en el cuadro de diálogo del archivo descargado. Si se omite el segundo parámetro, defaultFileName , se utiliza el nombre de archivo del URL especificado.

El siguiente código descarga un archivo denominado index.xml desde el mismo directorio que el archivo SWF:

var request:URLRequest = new URLRequest("index.xml"); 
var fileRef:FileReference = new FileReference(); 
fileRef.download(request);

Para establecer currentnews.xml como nombre predeterminado, en lugar de index.xml, es necesario especificar el parámetro defaultFileName , como se muestra en el siguiente fragmento de código:

var request:URLRequest = new URLRequest("index.xml"); 
var fileToDownload:FileReference = new FileReference(); 
fileToDownload.download(request, "currentnews.xml");

Cambiar el nombre de un archivo puede ser muy útil si el nombre de archivo del servidor no es intuitivo o ha sido generado por el servidor. También se recomienda especificar de forma explícita el parámetro defaultFileName cuando se descarga un archivo mediante un script de servidor, en lugar de descargarlo directamente. Por ejemplo, es necesario especificar el parámetro defaultFileName si se dispone de un script de servidor que descarga archivos específicos en función de las variables de URL que se le pasan. De lo contrario, el nombre predeterminado del archivo descargado es el nombre del script de servidor.

Es posible enviar datos al servidor mediante el método download() añadiendo parámetros al URL, para que los analice el script de servidor. El siguiente fragmento de código ActionScript 3.0 descarga un documento en función de los parámetros pasados a un script de ColdFusion:

package 
{ 
    import flash.display.Sprite; 
    import flash.net.FileReference; 
    import flash.net.URLRequest; 
    import flash.net.URLRequestMethod; 
    import flash.net.URLVariables; 
 
    public class DownloadFileExample extends Sprite 
    { 
        private var fileToDownload:FileReference; 
        public function DownloadFileExample() 
        { 
            var request:URLRequest = new URLRequest(); 
            request.url = "http://www.[yourdomain].com/downloadfile.cfm"; 
            request.method = URLRequestMethod.GET; 
            request.data = new URLVariables("id=2"); 
            fileToDownload = new FileReference(); 
            try 
            { 
                fileToDownload.download(request, "file2.txt"); 
            } 
            catch (error:Error) 
            { 
                trace("Unable to download file."); 
            } 
        } 
    } 
}

El siguiente código muestra el script ColdFusion, download.cfm, que descarga uno de los dos archivos del servidor, dependiendo del valor de una variable de URL:

<cfparam name="URL.id" default="1" /> 
<cfswitch expression="#URL.id#"> 
    <cfcase value="2"> 
        <cfcontent type="text/plain" file="#ExpandPath('two.txt')#" deletefile="No" /> 
    </cfcase> 
    <cfdefaultcase> 
        <cfcontent type="text/plain" file="#ExpandPath('one.txt')#" deletefile="No" /> 
    </cfdefaultcase> 
</cfswitch>

La clase FileReferenceList permite al usuario seleccionar uno o varios archivos para cargarlos en un script de servidor. La carga de archivos se controla mediante el método FileReference.upload() , al que es necesario llamar en cada archivo que selecciona el usuario.

El siguiente código crea dos objetos FileFilter ( imageFilter y textFilter ) y los pasa en un conjunto al método FileReferenceList.browse() . Como consecuencia, el cuadro de diálogo del archivo del sistema operativo muestra dos filtros de tipos de archivo posibles.

var imageFilter:FileFilter = new FileFilter("Image Files (*.jpg, *.jpeg, *.gif, *.png)", "*.jpg; *.jpeg; *.gif; *.png"); 
var textFilter:FileFilter = new FileFilter("Text Files (*.txt, *.rtf)", "*.txt; *.rtf"); 
var fileRefList:FileReferenceList = new FileReferenceList(); 
try 
{ 
    var success:Boolean = fileRefList.browse(new Array(imageFilter, textFilter)); 
} 
catch (error:Error)  
{ 
    trace("Unable to browse for files."); 
}

Permitir al usuario seleccionar y cargar uno o varios archivos mediante la clase FileReferenceList equivale a utilizar FileReference.browse() para seleccionar archivos, aunque FileReferenceList permite seleccionar más de un archivo. Para cargar varios archivos es necesario actualizar cada uno de los archivos seleccionados mediante FileReference.upload() , como se muestra en el siguiente código:

var fileRefList:FileReferenceList = new FileReferenceList(); 
fileRefList.addEventListener(Event.SELECT, selectHandler); 
fileRefList.browse(); 
 
function selectHandler(event:Event):void 
{ 
    var request:URLRequest = new URLRequest("http://www.[yourdomain].com/fileUploadScript.cfm"); 
    var file:FileReference; 
    var files:FileReferenceList = FileReferenceList(event.target); 
    var selectedFileArray:Array = files.fileList; 
    for (var i:uint = 0; i < selectedFileArray.length; i++) 
    { 
        file = FileReference(selectedFileArray[i]); 
        file.addEventListener(Event.COMPLETE, completeHandler); 
        try 
        { 
            file.upload(request); 
        } 
        catch (error:Error) 
        { 
            trace("Unable to upload files."); 
        } 
    } 
} 
function completeHandler(event:Event):void 
{ 
    trace("uploaded"); 
}

Dado que el evento Event.COMPLETE se añade a cada objeto FileReference individual del conjunto, Flash Player llama al método completeHandler() cuando finaliza la carga de cada uno de los archivos.