Verwenden der FileReference-Klasse

Jedes FileReference-Objekt stellt eine einzelne Datendatei auf dem lokalen Computer dar. Die Eigenschaften der FileReference-Klasse umfassen Informationen zu Dateigröße, Dateityp, Dateiname, Dateinamenerweiterung, Ersteller, Erstellungs- sowie Änderungsdatum.

Eine Instanz der FileReference-Klasse kann mit zwei Verfahren erstellt werden:

• Verwenden Sie den new -Operator, wie im folgenden Codebeispiel gezeigt:

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

• Rufen Sie die Methode FileReferenceList.browse() auf. Dadurch wird ein Dialogfeld geöffnet, in dem der Benutzer aufgefordert wird, eine oder mehrere Dateien für den Upload auszuwählen. Nachdem der Benutzer eine oder mehrere Dateien ausgewählt hat, wird ein Array aus FileReference-Objekten erstellt.

Nach der Erstellung eines FileReference-Objekts haben Sie folgende Möglichkeiten:

• Rufen Sie die FileReference.browse() -Methode auf. Dadurch wird ein Dialogfeld geöffnet, in dem der Benutzer aufgefordert wird, genau eine Datei im lokalen Dateisystem auszuwählen. Dies erfolgt normalerweise vor einem späteren Aufruf der Methode FileReference.upload() oder FileReference.load() . Rufen Sie die FileReference.upload() -Methode auf, um die Datei auf einen Remoteserver hochzuladen. Rufen Sie die FileReference.load() -Methode auf, um eine lokale Datei zu öffnen.

• Rufen Sie die FileReference.download() -Methode auf. Die download -Methode öffnet ein Dialogfeld, in dem der Benutzer ein Verzeichnis zum Speichern einer neuen Datei auswählen kann. Dann werden Daten vom Server heruntergeladen und in der neuen Datei gespeichert.

• Rufen Sie die FileReference.load() - Methode auf. Diese Methode beginnt, Daten aus einer vor Verwendung der browse() -Methode ausgewählten Datei zu laden. Die load() -Methode kann erst aufgerufen werden, wenn der browse() -Vorgang abgeschlossen ist (der Benutzer eine Datei auswählt).

• Rufen Sie die FileReference.save() -Methode auf. Diese Methode öffnet ein Dialogfeld und fordert den Benutzer auf, einen einzelnen Dateispeicherort im lokalen Dateisystem auszuwählen. Die Daten werden dann am angegebenen Speicherort gespeichert.

Die Eigenschaften des FileReference-Objekts, wie name , size oder modificationDate , werden erst nach einem der folgenden Vorgänge definiert:

• Die FileReference.browse() -Methode oder die FileReferenceList.browse() -Methode wurde aufgerufen und der Benutzer hat eine Datei im Dialogfeld ausgewählt.

• Die FileReference.download() -Methode wurde aufgerufen und der Benutzer hat ein neues Verzeichnis für die Datei im Dialogfeld angegeben.

Während Aufrufe der Methode FileReference.browse() , FileReferenceList.browse() , FileReference.download() , FileReference.load() oder FileReference.save() ausgeführt werden, setzen die meisten Player die Wiedergabe der SWF-Datei fort, einschließlich Ereignisauslösung und Codeausführung.

Bei Upload- und Download-Vorgängen kann mit einer SWF-Datei nur auf Dateien in der eigenen Domäne und in den in einer Richtliniendatei angegebenen Domänen zugegriffen werden. Sie müssen auf dem Server mit der Datei eine Richtliniendatei ablegen, falls sich dieser Server nicht in derselben Domäne wie die SWF-Datei befindet, die den Upload oder Download eingeleitet hat.

Siehe FileReference .

Mit der FileReference.load() -Methode können Sie Daten aus einer lokalen Datei in den Arbeitsspeicher laden.

Die Rückgabe von der FileReference.load() -Methode erfolgt direkt nach dem Aufrufen, die Daten, die geladen werden, stehen jedoch nicht sofort zur Verfügung. Das FileReference-Objekt löst Ereignisse aus, um bei jedem Schritt des Ladevorgangs Listener-Methoden aufzurufen.

Das FileReference-Objekt löst beim Speichern der Datei die folgenden Ereignisse aus.

• open -Ereignis ( Event.OPEN ): Wird ausgelöst, wenn der Ladevorgang beginnt.

• progress -Ereignis ( ProgressEvent.PROGRESS ): Wird regelmäßig ausgelöst, während Daten-Bytemengen aus der Datei gelesen werden.

• complete -Ereignis ( Event.COMPLETE ): Wird ausgelöst, wenn das Laden erfolgreich abgeschlossen wurde.

• ioError -Ereignis ( IOErrorEvent.IO_ERROR ): Wird ausgelöst, wenn der Ladevorgang fehlschlägt, weil beim Öffnen der Datei oder beim Lesen von Daten aus der Datei ein Eingabe-/Ausgabefehler auftritt.

Nachdem das FileReference-Objekt das complete-Ereignis ausgelöst hat, kann auf die geladenen Daten als ein ByteArray in der data -Eigenschaft des FileReference-Objekts zugegriffen werden.

Im folgenden Codebeispiel wird gezeigt, wie der Benutzer zur Auswahl einer Datei aufgefordert wird und wie die Daten dann aus dieser Datei in den Arbeitsspeicher geladen werden:

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

Der Beispielcode erstellt zuerst das FileReference-Objekt mit den Namen fileRef und ruft dann dessen browse() -Methode auf. Die browse -Methode öffnet ein Dialogfeld, das den Benutzer zum Auswählen einer Datei auffordert. Wenn eine Datei ausgewählt wird, ruft der Code die onFileSelected() -Methode auf. Diese Methode fügt Listener für die progress - und complete -Ereignisse hinzu und ruft dann die load() -Methode des FileReference-Objekts auf. Die anderen Prozedurmethoden im Beispiel geben Meldungen aus, um den Fortschritt des Ladevorgangs zu melden. Wenn der Ladevorgang abgeschlossen ist, zeigt die Anwendung den Inhalt der geladenen Datei mithilfe der trace() -Methode an.

In Adobe AIR bietet die FileStream-Klasse zusätzliche Funktionen zum Lesen von Daten aus einer lokalen Datei. Lesen Sie dazu Lese- und Schreibvorgänge in Dateien .

Mit der FileReference.save() -Methode können Sie Daten in einer lokalen Datei speichern. Zunächst wird ein Dialogfeld geöffnet, in dem der Benutzer einen neuen Dateinamen sowie das Verzeichnis zum Speichern der Datei eingeben kann. Nachdem der Benutzer den Dateinamen und den Speicherort ausgewählt hat, werden die Daten in die neue Datei geschrieben. Wenn die Datei erfolgreich gespeichert wurde, werden die Eigenschaften des FileReference-Objekts mit den Eigenschaften der lokalen Datei gefüllt.

Die Rückgabe der FileReference.save() -Methode erfolgt unmittelbar nach ihrem Aufruf. Dann löst das FileReference-Objekt Ereignisse aus, um bei jedem Schritt des Speichervorgangs Listener-Methoden aufzurufen.

Das FileReference-Objekt löst beim Speichern der Datei die folgenden Ereignisse aus:

• select -Ereignis ( Event.SELECT ): Wird ausgelöst, wenn der Benutzer das Verzeichnis und den Dateinamen für die neue Datei festlegt, die gespeichert werden soll.

• cancel -Ereignis ( Event.CANCEL ): Wird ausgelöst, wenn der Benutzer im Dialogfeld auf die Schaltfläche „Abbrechen“ klickt.

• open -Ereignis ( Event.OPEN ): Wird ausgelöst, wenn der Speichervorgang beginnt.

• progress -Ereignis ( ProgressEvent.PROGRESS ): Wird regelmäßig ausgelöst, während Daten-Bytemengen in der Datei gespeichert werden.

• complete -Ereignis ( Event.COMPLETE ): Wird ausgelöst, wenn das Speichern erfolgreich abgeschlossen wurde.

• ioError -Ereignis ( IOErrorEvent.IO_ERROR ): Wird ausgelöst, wenn der Speichervorgang fehlschlägt, weil beim Versuch, die Daten in der Datei zu speichern, ein Eingabe-/Ausgabefehler auftritt.

Der im data -Parameter der FileReference.save() -Methode übergebene Objekttyp bestimmt, wie die Daten in die Datei geschrieben werden:

• Bei einem String-Wert werden die Daten als Textdatei in UTF-8-Kodierung gespeichert.

• Bei einem XML-Objekt werden die Daten in eine Datei im XML-Format geschrieben, wobei die gesamte Formatierung beibehalten wird.

• Bei einem ByteArray-Objekt wird der Inhalt ohne Konvertierung direkt in die Datei geschrieben.

• Bei allen anderen Objekten ruft die FileReference.save() -Methode die toString() -Methode des Objekts auf und speichert dann den resultierenden String-Wert in einer Textdatei in UTF-8-Kodierung. Wenn die toString() -Methode des Objekts nicht aufgerufen werden kann, wird ein Fehler ausgegeben.

Wenn der data -Parameter den Wert null hat, wird ein Fehler ausgegeben.

Der folgende Code erweitert das vorstehende Beispiel für die FileReference.load() -Methode. Nachdem die Daten aus der Datei gelesen wurden, wird der Benutzer in diesem Beispiel zur Angabe eines Dateinamens aufgefordert. Dann werden die Daten in einer neuen Datei gespeichert:

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

Wenn alle Daten aus der Datei geladen wurden, ruft der Code die onComplete() -Methode auf. Die onComplete() -Methode entfernt die Listener für die Ladeereignisse und ruft dann die saveFile() -Methode auf. Die saveFile() -Methode ruft die FileReference.save() -Methode auf. Die FileReference.save() -Methode öffnet ein neues Dialogfeld, in dem der Benutzer einen neuen Dateinamen eingeben und den Speicherort der Datei auswählen kann. Die restlichen Ereignis-Listener-Methoden verfolgen den Fortschritt des Speichervorgangs bis zum Abschluss.

In Adobe AIR bietet die FileStream-Klasse zusätzliche Funktionen zum Schreiben von Daten in eine lokale Datei. Lesen Sie dazu Lese- und Schreibvorgänge in Dateien .

Zum Hochladen von Dateien auf einen Server rufen Sie zunächst die browse() -Methode auf, damit ein Benutzer eine oder mehrere Dateien auswählen kann. Dann, nachdem die FileReference.upload() -Methode aufgerufen wurde, wird die ausgewählte Datei an den Server übertragen. Wählt der Benutzer mehrere Dateien mit der Methode FileReferenceList.browse() aus, erstellt Flash Player ein Array der ausgewählten Dateien mit der Bezeichnung FileReferenceList.fileList . Sie können dann die FileReference.upload() -Methode verwenden, um die Dateien einzeln hochzuladen.

Standardmäßig können Benutzer auf dem lokalen Computer einen beliebigen Dateityp im Dialogfeld zur Dateiauswahl auswählen. Entwickler können mit der FileFilter-Klasse und durch Übergeben eines Arrays mit Dateifilterinstanzen an die browse() -Methode einen oder mehrere benutzerdefinierte Filter für Dateitypen angeben:

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

Nachdem der Benutzer die Dateien ausgewählt und im Dialogfeld zur Dateiauswahl auf die Schaltfläche zum Öffnen der Datei geklickt hat, wird das Event.SELECT -Ereignis ausgelöst. Wird die FileReference.browse() -Methode zur Auswahl einer hochzuladenden Datei verwendet, sendet der folgende Code die Datei an einen Webserver:

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

Mit der FileReference.upload() -Methode können Sie Daten an den Server senden, indem Sie die Eigenschaften URLRequest.method und URLRequest.data verwenden, um Variablen mit den Methoden POST oder GET zu senden.

Wenn Sie versuchen, eine Datei mit der FileReference.upload() -Methode hochzuladen, werden die folgenden Ereignisse ausgelöst:

• open -Ereignis ( Event.OPEN ): Wird ausgelöst, wenn der Uploadvorgang beginnt.

• progress -Ereignis ( ProgressEvent.PROGRESS ): Wird regelmäßig ausgelöst, während Daten-Bytemengen aus der Datei hochgeladen werden.

• complete -Ereignis ( Event.COMPLETE ): Wird ausgelöst, wenn der Uploadvorgang erfolgreich abgeschlossen wurde.

• httpStatus -Ereignis ( HTTPStatusEvent.HTTP_STATUS ): Wird ausgelöst, wenn ein Upload-Vorgang aufgrund eines HTTP-Fehlers fehlschlägt.

• httpResponseStatus -Ereignis ( HTTPStatusEvent.HTTP_RESPONSE_STATUS ): Wird ausgelöst, wenn ein Aufruf der upload() - oder uploadUnencoded() -Methode versucht, über HTTP auf Daten zuzugreifen, und Adobe AIR den Statuscode für die Anforderung erkennen und zurückgeben kann.

• securityError -Ereignis ( SecurityErrorEvent.SECURITY_ERROR ): Wird ausgelöst, wenn ein Upload-Vorgang aufgrund einer Sicherheitsverletzung fehlschlägt.

• uploadCompleteData -Ereignis DataEvent.UPLOAD_COMPLETE_DATA ): Wird ausgelöst, nachdem Daten vom Server nach einem erfolgreichen Upload empfangen wurden.

• ioError -Ereignis ( IOErrorEvent.IO_ERROR ): Wird ausgelöst, wenn der Upload-Vorgang aus einem der folgenden Gründe fehlschlägt:

  • Während des Lese-, Schreib- oder Übertragungsvorgangs durch Flash Player ist ein Eingabe/Ausgabe-Fehler aufgetreten.

  • Die SWF-Datei versuchte, eine Datei auf einen Server hochzuladen, der eine Authentifizierung erfordert (z. B. anhand eines Benutzernamens und eines Kennworts). Während des Uploads stellt Flash Player keine Möglichkeiten für die Eingabe von Kennwörtern durch die Benutzer bereit.

  • Der Parameter url enthält ein ungültiges Protokoll. Die FileReference.upload() -Methode muss entweder HTTP oder HTTPS verwenden.

Flash Player bietet keine Unterstützung für Server, die eine Authentifizierung erfordern. Nur bei SWF-Dateien, die in einem Browser mithilfe des Browser-Plug-Ins oder des Microsoft ActiveX®-Steuerelements ausgeführt werden, kann der Benutzer in einem Dialogfeld zur Eingabe eines Benutzernamens und eines Kennworts zur Authentifizierung aufgefordert werden. Dies gilt jedoch nur für Downloadvorgänge. Upload-Vorgänge mit Plug-Ins oder ActiveX-Steuerelementen bzw. Upload/Download-Vorgänge mit dem eigenständigen oder externen Player schlagen fehl.

Wenn Sie ein Serverskript in ColdFusion erstellen möchten, um einen Datei-Upload von Flash Player zu akzeptieren, können Sie Code wie den Folgenden verwenden:

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

Dieser ColdFusion-Code lädt die von Flash Player gesendete Datei hoch und speichert sie im gleichen Verzeichnis wie die ColdFusion-Vorlage. Dabei wird eine Datei mit dem gleichen Namen überschrieben. Das vorangegangene Codebeispiel zeigt den mindestens erforderlichen Code, der zum Akzeptieren eines Datei-Uploads erforderlich ist. Dieses Skript sollte in einer Produktionsumgebung nicht verwendet werden. Im Idealfall fügen Sie eine Datenvalidierung hinzu, um sicherzustellen, dass Benutzer nur akzeptierte Dateitypen hochladen, beispielsweise eine Bilddatei anstelle eines potenziell gefährlichen serverseitigen Skripts.

Der folgende Code demonstriert Datei-Uploads mithilfe von PHP und umfasst eine Datenvalidierung. Das Skript beschränkt die Anzahl der hochgeladenen Dateien im Upload-Verzeichnis auf 10, und stellt sicher, dass die Datei kleiner als 200 KB ist. Weiterhin werden das Hochladen und die Speicherung im Dateisystem auf Dateien des Typs JPEG, GIF oder PNG beschränkt.

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

Mit der POST - oder GET -Anforderungsmethode können Sie zusätzliche Variablen an das Upload-Skript übergeben. Sie können den folgenden Code verwenden, um zusätzliche POST -Variablen an Ihr Upload-Skript zu übergeben:

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

Das vorangegangene Codebeispiel erstellt ein URLVariables-Objekt, das Sie an das externe serverseitige Skript übergeben. In früheren Versionen von ActionScript konnten Sie Variablen durch Angabe von Werten im Abfrage-String an das Server-Upload-Skript übergeben. Mit ActionScript 3.0 können Sie Variablen mit einem URLRequest-Objekt an das externe Skript übergeben. Dies ermöglicht Ihnen die Übergabe von Daten mit der POST - oder GET -Methode, und das wiederum macht die Übergabe längerer Datensätze einfacher und übersichtlicher. Um anzugeben, welche Variablen mit der Anforderungsmethode GET oder POST übergeben werden, können Sie die Eigenschaft URLRequest.method auf URLRequestMethod.GET bzw. URLRequestMethod.POST einstellen.

ActionScript 3.0 ermöglicht Ihnen darüber hinaus das Überschreiben des standardmäßigen Namens für das Filedata -Upload-Dateifeld, indem Sie einen zweiten Parameter für die Methode upload() angeben. Dies wurde im vorangegangenen Codebeispiel demonstriert (in dem der Standardwert Filedata durch Custom1 ersetzt wurde).

In der Standardeinstellung versucht Flash Player nicht, einen Test-Upload zu senden, obwohl Sie diese Standardeinstellung außer Kraft setzen können, indem Sie true als dritten Parameter für die upload() -Methode angeben. Der Zweck eines Test-Upload besteht darin, zu überprüfen, ob der tatsächliche Datei-Upload erfolgreich verlaufen wird und ob eine Authentifizierung beim Server (falls erforderlich) erfolgreich sein wird.

Das den Upload verwaltende Serverskript erwartet eine HTTP POST -Anforderung mit den folgenden Elementen:

• Content-Type mit einem Wert von multipart/form-data

• Content-Disposition mit einem Attribut name , das auf „Filedata" eingestellt ist, und mit einem Attribut filename , das auf den Namen der Originaldatei eingestellt ist. Sie können ein benutzerdefiniertes name -Attribut angeben, indem Sie einen Wert für den uploadDataFieldName -Parameter in der FileReference.upload() -Methode übergeben.

• Die binären Inhalte der Datei.

Im Folgenden finden Sie ein Beispiel einer HTTP POST -Anforderung:

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

Das folgende Beispiel einer HTTP POST -Anforderung sendet drei POST -Variablen: api_sig , api_key und auth_token . Weiterhin wird ein benutzerdefinierter Upload-Datenfeldname von „photo" verwendet:

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

Mit der Methode FileReference.download() können Sie Benutzern das Herunterladen von Dateien von einem Server ermöglichen. Dieser Methode lässt zwei Parametern zu: request und defaultFileName . Der erste Parameter ist ein URLRequest-Objekt, das die URL der herunterzuladenden Datei enthält. Der zweite Parameter ist optional. Mit ihm können Sie einen standardmäßigen Dateinamen angeben, der im Dialogfeld zum Herunterladen der Datei angezeigt wird. Wenn Sie den zweiten Parameter, defaultFileName , weglassen, wird der Dateiname aus der angegebenen URL verwendet.

Mit dem folgenden Code wird eine Datei namens „index.xml“ aus dem gleichen Verzeichnis wie die SWF-Datei heruntergeladen:

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

Um den Standardnamen von „index.xml“ in „currentnews.xml“ zu ändern, verwenden Sie den defaultFileName -Parameter. Dies wird im folgenden Codeausschnitt gezeigt:

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

Das Umbenennen einer Datei ist insbesondere dann sinnvoll, wenn der Dateiname auf dem Server nicht besonders intuitiv ist oder vom Server erzeugt wurde. Außerdem sollten Sie den Parameter defaultFileName explizit angeben, wenn Sie eine Datei mit einem serverseitigen Skript und nicht direkt herunterladen. Beispielsweise müssen Sie den Parameter defaultFileName angeben, wenn Sie mit einem serverseitigen Skript arbeiten, das bestimmte Dateien basierend auf den an das Skript übergebenen URL-Variablen herunterlädt. Andernfalls wird der Name Ihres serverseitigem Skripts zum Standardnamen der heruntergeladenen Datei.

Daten können mit der download() -Methode an den Server übertragen werden, indem Sie der URL Parameter hinzufügen, die das Serverskript analysiert. Mit dem folgenden ActionScript 3.0-Codeausschnitt wird ein Dokument basierend auf den Parametern heruntergeladen, die an ein ColdFusion-Skript übergeben wurden:

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

Der folgende Code zeigt das ColdFusion-Skript „download.cfm“, das abhängig vom Wert der URL-Variablen eine von zwei Dateien vom Server herunterlädt:

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

Mit der FileReferenceList-Klasse können Benutzer eine oder mehrere Dateien zum Hochladen an ein serverseitiges Skript auswählen. Der Datei-Upload wird von der FileReference.upload() -Methode verarbeitet, die für jede vom Benutzer ausgewählte Datei aufgerufen werden muss.

Mit dem folgenden Code werden zwei FileFilter-Objekte ( imageFilter und textFilter ) erstellt und in einem Array an die FileReferenceList.browse() -Methode übergeben. Dies sorgt dafür, dass das Datei-Dialogfeld des Betriebssystems zwei mögliche Filter für Dateitypen anzeigt.

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

Das Auswählen und Hochladen einer oder mehrerer Dateien mithilfe der FileReferenceList-Klasse ist das Gleiche wie das Verwenden von FileReference.browse() zur Auswahl von Dateien, obwohl mit FileReferenceList mehrere Dateien gleichzeitig ausgewählt werden können. Beim Hochladen mehrerer Dateien müssen Sie jede ausgewählte Datei mit FileReference.upload() hochladen. Dies wird im folgenden Code gezeigt:

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

Da das Ereignis Event.COMPLETE jedem einzelnen FileReference-Objekt im Array hinzugefügt wird, ruft Flash Player die Methode completeHandler() auf, wenn das Hochladen für jede einzelne Datei abgeschlossen ist.