Nachladen von Variablen aus Texten oder PHP-Files

Flash bietet uns die Möglichkeit, von außerhalb des Filmes sowohl andere Filme und Bilder wie auch zusätzliche Daten nachzuladen. Die etwas veralteten Funktionen loadVariables und loadVariablesNum sollten dazu aber nicht mehr verwendet werden, da sie asynchron zu anderen Scriptbefehlen laufen und keine eigenen Rückmeldungen dazu liefern, wie der Response eigentlich aussieht.

Schauen wir uns deshalb das aktuelle Übertragungsmedium, die LoadVars-Klasse an:

Die LoadVars-Klasse bietet Flash die Möglichkeit, dynamische Daten in Form von Variablen sowohl an eine externe Quelle zu senden, als auch von einer externen Quelle zu empfangen.

Diese externen Quellen können zum Beispiel Textfiles sein oder serverbasierte Middleware-Scripte wie PHP- oder ASP-Files. Über diese Middleware wiederum können auch Datenbankenabfragen z.B. von mySQL-Datenbanken eingebunden werden.

Die wichtigsten drei Methoden der LoadVars-Klasse sind:
LoadVars.onLoad()
LoadVars.load()
LoadVars.send()
und die Kombination aus den letzten beiden:
LoadVars.sendAndLoad().

Auf die weiteren Methoden wird hier nicht näher eingegangen.

LoadVars.load() lädt externe Variablen aus einem lokalen oder externen Textfile oder einem Server-basierten Middleware-Script, z.B. von einem PHP-File.

Aus dem Text holt sich diese Methode URL-enkodierte Variablen, bzw. vom Script empfängt sie Variablen und wandelt sie in Eigenschaften des LoadVars-Objektes um.

Übergabeparameter für LoadVars.load ist eine URL, d.h. ein String, der den Pfad zu der Quelle - also dem Serverbasierten Script oder dem Textfile - angibt.

Die load-Methode kann allerdings nur den Download einer URL-enkodierten Variable initiieren, Rückgabewerte kann nur die onLoad-Methode erhalten. Der Rückgabewert der onLoad-Methode ist ein Boolean-Wert, also ein true oder false. Mit diesen Werten kann dann überprüft werden, ob der HTTP-Response, also die Antwort des Servers, nicht leer war.

Das bedeutet dann allerdings nicht, dass der übergebene Wert formatiert oder nützlich war, sondern eben nur, dass ein Wert übergeben wurde.

LoadVars.send() funktioniert ähnlich wie der getURL-Befehl. Als Parameter können ein URL-encodierter String, ein Ziel-String und ein HTTP-Methodenstring übergeben werden.

Der Zielstring spezifiziert einen Fensternamen oder Framenamen des Browsers, zu dem Resultate gesendet werden sollen. Es kann aber auch einer der vordefinierten Typen "_blank" für eine leere Browserseite, "_parent" für das derzeitige Frameset, welches den Film enthält, "_top" für das Ersetzen aller Framesets oder "_self" für das derzeitige Fenster gesetzt werden.

Die send-Methode hat gegenüber dem getURL allerdings den Vorteil, dass spezifizierte Variablen als Eigenschaft an ein externes Script übergeben werden können, wobei getURL an einen MC gebunden ist, der die Variablen enthält.

LoadVars.sendAndLoad() konvertiert alle Eigenschaften des loadVars-Objektes in einen URL-enkodierten String und sendet ihn in einem HTTP-Request an eine in der Parameterliste angegebene URL. Genau wie bei der load-Methode erwartet das Objekt dann einen Rückgabewert.

Vorteil gegenüber der send-Methode ist, dass spezielle Variablen als Eigenschaften des Objektes übergeben werden können. Dies ist auch ein großer Vorteil gegenüber Befehlen wie loadVariables und loadVariablesNum, bei denen alle Variablen der aktuellen Zeitleiste übergeben werden. Weiterhin kann anders als bei der send-Methode als HTTP-Methode auch POST genutzt werden.

Schauen wir uns jetzt einmal an, wie die LoadVars-Klasse in der Praxis genutzt wird:

Wir wollen bspw. aus einem Textfile ein Wertepaar laden, der Eintrag im Textfile lautet dann etwa:

&meinEintrag=meinWert&

, das Textfile hat den Dateinamen "meinFile.txt", das File bitte als Unicode-Format UTF-8 abspeichern. In PHP könnte eine entsprechende Ausgabe so aussehen:

PHP-Code:

$meinEintrag="meinWert";
echo "&meinEintrag=".$meinEintrag."&"; 


Im Actionscript-Editor legen wir zuerst eine Instanz des LoadVars-Objektes mit new an, da wir nichtstatische Klasse selbst nicht direkt verwenden können:

PHP-Code:

lv = new LoadVars(); 


Danach erstellen wir uns eine Callback-Funktion, die den Response des LoadVars-Objektes aufnimmt:

PHP-Code:

function geladen(erfolgreich) {}
lv.onLoad = geladen; 


Als letztes wird das Objekt als HTTP-Request an das Textfile gesendet:

PHP-Code:

lv.load("meinFile.txt",lv,"POST");//im Firefox funktioniert manchmal nur ein "GET" statt des "POST"! 


Die Callback-Funktion "geladen" wird danach mit Leben gefüllt, da wir nicht nur einen boolschen Rückgabewert erwarten, sondern auch die HTTP-Antwort mit der gesendeten Variable:

PHP-Code:

function geladen(erfolgreich) {
        if(erfolgreich) {
             trace("empfangene Variable: "+this.meinEintrag);
        }
        else {
                trace("Fehler beim Laden");
        }
} 


Das komplette Script könnte dann so aussehen:

PHP-Code:

function geladen(erfolgreich) {
        if(erfolgreich) {
             trace("empfangene Variable: "+this.meinEintrag);
        }
        else {
                trace("Fehler beim Laden");
        }
}
lv = new LoadVars();//Instanz erstellen
lv.onLoad = geladen;//Callback setzen
lv.load("meinFile.txt",lv,"POST");//und den Request starten 


Wenn alles richtig eingegeben war, bekommt man dann im Testmodus (STRG-ENTER) im Ausgabefenster "empfangene Variable: meinWert";

Da der Response immer ein String ist, sollte eine Numbervariable vor der weiteren Verwendung im Script bspw. mit Number(meineVariable) umgewandelt werden.

Wichtig ist vor allem, dass der weitere Scriptverlauf über die Callback-Funktion "geladen" gesteuert werden sollte, da diese Funktion ja sozusagen im "Hintergrund" solange wartet, bis ein Response erfolgt. Erst in diesem Callback kann auf die Variablen zugegriffen werden, die bspw. dann in einem Textfeld ausgegeben werden sollen. Auch hierzu ein Beispiel:

PHP-Code:

function geladen(erfolgreich) {
        if(erfolgreich) {
             trace("empfangene Variable: "+this.meinEintrag);
             _level0.meineTextfeldinstanz.text = this.meinEintrag;
        }
        else {
                trace("Fehler beim Laden");
        }
} 


Wenn mal mehrere Variablen nachgeladen werden sollen, so kann man sich bspw. kommaseparierte Listen im Textfile (oder via PHP) erstellen, in Flash einlesen und ein Array splitten. Dazu wieder ein Beispiel für ein Textfile:

&meineVarliste=wert1,wert2,wert3&

Der onLoad-Callback könnte dann etwa so aussehen (die LoadVars-Initialisierungen ändern sich nicht):

PHP-Code:

function geladen(erfolgreich) {
        if(erfolgreich) {
             trace("empfangene Variablen: "+this.meineVarliste);
             _level0.meineVariablen = this.meineVarliste.split(",");//die Variablen werden jetzt in ein Array gesplittet
             //danach kann man die Einträge des Arrays bspw. mit einer for-Schleife auslesen:
             var len = _level0.meineVariablen.length;//Länge des Arrays ermitteln
             for(var i=0;i<len;i++){//das gesamte Array durchwandern
                 trace("_level0.meineVariablen["+i+"]="+_level0.meineVariablen[i]);
             }
        }
        else {
                trace("Fehler beim Laden");
        }
} 


Danach liegen die gesendeten Variablen in _level0.meineVariablen[0],_level0.meineVariablen[1] und _level0.meineVariablen[2].

Diese Scripte kann man auch verwenden, wenn man an ein PHP-File Daten senden will, bspw. um diese Daten in ein Textfile zu speichern oder an eine Datenbank zu senden etc.

Folgendes Script sendet gezielt eine Variable an ein PHP-Script:

PHP-Code:

lv = new LoadVars();//Instanz erstellen
lv.onLoad = geladen;//Callback setzen

lv.meineVariable = "meinWert";//diese Variable mit der loadVars-Klasse an ein Script senden

lv.sendAndLoad("mein.php",lv,"POST");//und den Request starten 


In PHP kann man die gesendete Variable mit der globalen Variablen $_POST empfangen und weiterverwenden, bspw.:

PHP-Code:

<?php
$empfangeneVar = $_POST["meineVariable"];
?>

Wer ganz sicher gehen will, dass auch die richtige Variable angekommen ist, kann sich diese jetzt auch wieder an seinen Flash-Film über den onLoad-Callback zurücksenden lassen:

PHP-Code:

<?php
$empfangeneVar = $_POST["meineVariable"];
echo"&rueckgabe=".$empfangeneVar."&";
?>

Und im Flashfilm den onLoad-Callback setzen, wie weiter oben schon erwähnt:

PHP-Code:

function geladen(erfolgreich) {
        if(erfolgreich) {
             trace("empfangene Variable: "+this.rueckgabe);
        }
        else {
                trace("Fehler beim Laden");
        }
} 


So, als Ergänzung mal das Nachladen von Variablen aus einem Textfile mit Actionscript 3, Textfile beispiel.txt:

eintrag1=blafasel&eintrag2=beliebigerWert

PHP-Code:

//Lader.fla

//neue Instanz der Klasse erstellen
var myLoader = new TextfileExample();

//in die DisplayObject-Liste hängen
addChild(myLoader); 


PHP-Code:

//TextfileExample.as
package {
   import flash.display.Sprite;
   import flash.events.*;
   import flash.net.URLLoader;
   import flash.net.URLLoaderDataFormat;
   import flash.net.URLRequest;
   import flash.util.trace;

      public class TextfileExample extends Sprite {
        
    
        public function TextfileExample() {
                         
              //über den URLRequest das Textfile laden
              var request:URLRequest = new URLRequest("beispiel.txt");
              var loader:URLLoader = new URLLoader();
              loader.load(request);
              
              // hier zur Demo ein paar Listener, die das erfolgreiche (oder erfolglose) Laden dokumentieren können
              loader.addEventListener( IOErrorEvent.IO_ERROR, handleIOError );
              loader.addEventListener( HTTPStatusEvent.HTTP_STATUS, handleHttpStatus );
              loader.addEventListener( SecurityErrorEvent.SECURITY_ERROR, handleSecurityError );
              loader.addEventListener( Event.COMPLETE, handleComplete );//wenn erfolgreich geladen, dann weitermachen mit der Funktion handleComplete
        
              // den loader so einstellen, dass er aus dem Request Variablen ausliest, keine BINARY oder TEXT
              loader.dataFormat = URLLoaderDataFormat.VARIABLES;
        }
    
        function handleIOError( event:IOErrorEvent ):void {
          trace( "Load failed: IO error: " + event.text ); 
        }
    
        function handleHttpStatus( event:HTTPStatusEvent ):void {
          if(event.status >0){    
              trace( "Load failed: HTTP Status = " + event.status );
          }
        }
    
        function handleSecurityError( event:SecurityErrorEvent ):void {
          trace( "Load failed: Security Error: " + event.text );
        }
    
        function handleComplete( event:Event ):void {
            
            var loader:URLLoader = URLLoader(event.target);
            trace("loader.data="+loader.data);
            trace("\nloader.data.eintrag1="+loader.data.eintrag1);
            trace("\nloader.data.eintrag2="+loader.data.eintrag2);

        
        }
    
      }
}