Joscha Feth Dynamische Webseiten mit Flash und PHP
JOSCHA FETH
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
eBook Die nicht autorisierte Weitergabe dieses eBooks an Dritte ist eine Verletzung des Urheberrechts!
Die Deutsche Bibliothek – CIP-Einheitsaufnahme Ein Titeldatensatz für diese Publikation ist bei Der Deutschen Bibliothek erhältlich. Die Informationen in diesem Produkt werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht ausgeschlossen werden. Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für Verbesserungsvorschläge und Hinweise auf Fehler sind Verlag und Herausgeber dankbar. Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zulässig. Fast alle Hardware- und Softwarebezeichnungen, die in diesem Buch erwähnt werden, sind gleichzeitig eingetragene Warenzeichen oder sollten als solche betrachtet werden.
Umwelthinweis: Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt. Die Einschrumpffolie – zum Schutz vor Verschmutzung – ist aus umweltverträglichem und recyclingfähigem PE-Material.
10 9 8 7 6 5 4 3 2 1 05 04 03 02
ISBN 3-8272-6285-2
© 2002 by Markt+Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH Martin-Kollar-Straße 10-12, D-81829 München/Germany Alle Rechte vorbehalten Einbandgestaltung: Dominik Schech, Dresden (www.schech.net) Lektorat: Boris Karnikowski,
[email protected] Fachlektorat: Christian Wenz, München Korrektorat: Friederike Daenecke, Zülpich Herstellung: Monika Weiher,
[email protected] CD-Mastering: Gregor Kopietz,
[email protected] Satz: someTimes GmbH, München Druck und Verarbeitung: fgb, freiburger graphische betriebe, www.fgb.de Printed in Germany
INHALTSVERZEICHNIS 1 Einleitung ............................................................................................................................. 9 1.1
Über den Autor .......................................................................................................... 10
1.2
Über dieses Buch ........................................................................................................ 10
1.2.1 Danksagungen .............................................................................................................. 11 1.2.2 Formales ........................................................................................................................ 12
2 Grundlegendes zu PHP ...................................................................................................... 13 2.1
Über PHP .................................................................................................................... 14
2.2
Bezugsquellen für PHP ............................................................................................. 15
2.3
Installation von PHP .................................................................................................. 15
2.4
Einsatz der Skripte aus diesem Buch ...................................................................... 16
3 Dynamische Inhalte ............................................................................................................ 17 3.1
Variablen von PHP in Flash laden ........................................................................... Schema der Übergabe ................................................................................................... Funktionen für das Laden ............................................................................................. Korrekte Formatierung ................................................................................................. Arrays von PHP nach Flash übergeben ........................................................................ Variablen innerhalb des
- und <EMBED>-Tags an Flash übergeben ........... Caching-Verhalten ........................................................................................................ Beispiel: IP-Übergabe an Flash ...................................................................................... Umgang mit Verzögerungen .........................................................................................
18 18 18 20 28 35 37 41 43
3.2.1 3.2.2 3.2.3 3.2.4 3.2.5 3.2.6 3.2.7
Variablen von Flash an PHP übergeben ................................................................. Schema der Übergabe ................................................................................................... Funktionen zur Übergabe ............................................................................................. Verschiedene Übergabearten/Methoden ...................................................................... Auswahl der zu sendenden Variablen .......................................................................... Arrays ........................................................................................................................... Verarbeitung übergebener Daten in PHP ...................................................................... Beispiel: Übergabe und Manipulation eines Strings .....................................................
50 51 51 52 54 57 65 69
3.3
Beispiel: Ein Feedback-Formular ............................................................................. 71
3.1.1 3.1.2 3.1.3 3.1.4 3.1.5 3.1.6 3.1.7 3.1.8
3.2
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
6
Inhaltsverzeichnis
4 PHP, MySQL und Flash ....................................................................................................... 75 4.1 4.2 4.2.1 4.2.2 4.2.3 4.2.4 4.2.5
Interaktionsschema .................................................................................................... 76 Die Klasse swiffSQL .................................................................................................. 77 79 79 84 84 89
Wichtige Hinweise ........................................................................................................ Funktionsübersicht ....................................................................................................... Umgang mit der Klasse swiffSQL ................................................................................. Beispiel: Daten laden (Variablen) .................................................................................. Beispiel: Daten laden/einfügen (XML) .........................................................................
5 Umgang mit Flash und PHP ............................................................................................ 99 5.1
Scripts von anderen Servern ausführen/laden ................................................... 100
5.1.1 Proxy-Scripting ........................................................................................................... 100 5.1.2 DNS-Aliasing .............................................................................................................. 100
5.2
SSL mit Flash ............................................................................................................ 101
5.3
Beispiel: Passwortgeschützter Bereich in Flash ................................................... 102
5.4
Beispiel: Sessions mit Flash und PHP ................................................................... 107
5.5
Beispiel: Besucherzähler mit PHP und Flash ....................................................... 120
5.6
Beispiel: automatische Sprachauswahl mit Hilfe von PHP ............................... 128
6 Cookies mit Flash und PHP ............................................................................................ 133 6.1
Beispiel: Cookies setzen/löschen .......................................................................... 134
6.2
Wichtiges bei Verwendung von Cookies .............................................................. 144
6.3
Sicherheitsaspekte .................................................................................................... 145
7 XML mit Flash und PHP ................................................................................................... 147 7.1
Ein- und Ausgabe von Daten ................................................................................. 148
7.1.1 Funktionen .................................................................................................................. 148 7.1.2 Events ......................................................................................................................... 151 7.1.3 Eigenschaften .............................................................................................................. 152
7.2
Beispiel: Daten von PHP nach Flash übergeben .................................................. 154
7.3
Beispiel: Daten von Flash nach PHP übergeben .................................................. 160
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Inhaltsverzeichnis
7
8 Serverseitige Erzeugung von Flash-Inhalten ............................................................ 163 8.1
... mit Ming und PHP ............................................................................................... 164 164 165 166 168 173
8.1.1 8.1.2 8.1.3 8.1.4 8.1.5
Einbindung des Ming-Moduls .................................................................................... Wichtige Informationen zu Ming ................................................................................ Beispiel: Leeres SWF erzeugen .................................................................................... Beispiel: Konvertierung eines JPEGs in ein SWF ........................................................ Beispiel: Darstellung von Text .....................................................................................
8.2
... mit Swift-Generator und PHP ............................................................................ Voraussetzungen ......................................................................................................... Aufbau eines Flash-Films ............................................................................................ Erstellen von SWT-Dateien ......................................................................................... Dumps von SWT-Dateien erstellen ............................................................................. Der swiPHP-Wrapper ................................................................................................. Funktionsübersicht ..................................................................................................... Beispiel: Ersetzen eines Bildes durch ein anderes ....................................................... Beispiel: Ersetzen von Text und ActionScript .............................................................. Beispiel: Anwendung aller Funktionen .......................................................................
177 177 177 178 179 180 181 196 198 201
8.3
… mit der JPG2SWF-Klasse .................................................................................... 8.3.1 Funktionsübersicht ..................................................................................................... 8.3.2 Restriktionen ............................................................................................................... 8.3.3 Beispiel ........................................................................................................................
203 203 205 205
8.4
Weitere Alternativen (libswf) ................................................................................. 207
8.2.1 8.2.2 8.2.3 8.2.4 8.2.5 8.2.6 8.2.7 8.2.8 8.2.9
9 Flash MX ............................................................................................................................ 209 9.1
Neue Funktionen zum Datenaustausch ............................................................... 210
9.1.1 Funktionsübersicht ..................................................................................................... 210 9.1.2 Events ......................................................................................................................... 220 9.1.3 Eigenschaften .............................................................................................................. 221
10 flash.inc.php ...................................................................................................................... 223 10.1.1 Funktionsübersicht ..................................................................................................... 224
A Anhang ................................................................................................................................. 233 A.1 A.1.1 A.1.2 A.1.3 A.1.4
Boni ............................................................................................................................ 234 flaLittleShop (Onlineshop) .................................................................................................... 234 swFrog (Multiplayer-Applikation) ...................................................................................... 236 flashStats – Statistik in Flash ................................................................................................. 237 fdb – flash database ................................................................................................................ 237
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
8
Inhaltsverzeichnis
A.1.5 SWF2PNG – Gemaltes speichern ......................................................................................... 238 A.1.6 FlaWRITEonline ..................................................................................................................... 238 A.2.1 A.2.2 A.2.3 A.2.4
A.2
Ressourcen ................................................................................................................ 239 PHP ........................................................................................................................................... 239 Webserver ................................................................................................................................ 239 MySQL ..................................................................................................................................... 239 Sonstiges .................................................................................................................................. 240
A.3
PHP-Entwicklungsumgebungen ........................................................................... 241
A.3.1 Maguma PHP4EE Studio light ............................................................................................. 241 A.3.2 PHP Coder ............................................................................................................................... 242 A.3.3 PHP Edit .................................................................................................................................. 242
Index ..................................................................................................................................... 245
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
KAPITEL 1
EINLEITUNG
Crescit enim cum amplitudine rerum vis ingenii. (Denn mit der Größe der Aufgaben wächst die Kraft des Geistes) PUBLIUS CORNELIUS TACITUS
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
10
Kapitel 1
1.1 Über den Autor Joscha Falco Feth ist Programmierer und entwickelt Anwendungen und dynamische Internetseiten im eigenen Unternehmen. Zu seinem Sprachrepertoire gehören hauptsächlich PHP, SQL, Flash ActionScript, C/C++, Delphi und Perl. 1998 entdeckte Joscha die faszinierenden Möglichkeiten von Macromedias vektororientiertem Flash und dessen interne Programmiersprache »ActionScript«. Im Zusammenspiel mit serverseitigen Scriptsprachen war damit im Internet möglich, was sonst nur mit aufwändig programmierten Applikationen realisiert werden konnte. 1999 entwickelte Joscha Feth eine Flash-Seite, auf der dynamische Texteffekte generiert und im Flash-(SWF-)Format erstellt werden konnten. Die Nachfrage für diese Anwendung war so groß, dass er zusammen mit Wildform Inc. in Los Angeles eine eigenständige Anwendung für Windows entwickelte. Das Programm SWfX wurde bis heute schon einige tausend Mal verkauft und ist mittlerweile auch für Macintosh verfügbar (www.wildform. com). Anfang 2000 eröffnete Joscha Feth das Flash-Internetportal www.flashtool.de. Er bietet dort von ihm entwickelte Zusatz-Tools an, welche die Online- und Offlinefunktionalität von Flash erheblich steigern. Die Seite ist ein großer Erfolg und hat circa 15.000 Besucher pro Monat. Durch die Entwicklung eines auf Flash basierten Strategiespiels wurde Joscha Hauptgewinner des Software-Wettbewerbs 2000 von e-SAP und Sunshine Live. Ein sechswöchiges Intensivtraining bei SAP LABS FRANCE in Sophia-Antipolis, Frankreich, folgte. Noch im selben Jahr gründete Joscha Feth mit Jochen Schimmelpfennig und Dominik Schech www.e-motionshop.com. Im Team wird ein Flash-PHP-Internet-Shopsystem mit anspruchsvoller Grafik, komfortablem Administrationsbereich und Contentmanagement entwickelt (FLASH:BAG). Im Sommer 2001 entwickelte Joscha Feth bei Wildform, Inc., in Los Angeles, USA eine komplexe PHP-Flash-Video-Datenbank (Wildform Video Library). Die Videosequenzen sind für die Vorschau in Flash mit dem Programm Flix kodiert worden. Seit 2000 hält Joscha Feth regelmäßig Vorträge auf der Deutschen Flash-Konferenz und veranstaltet Schulungen für Flash. Jess Märtterer, www.de-de.de
1.2 Über dieses Buch Flash ist ein vektorbasiertes Grafikformat, das aufgrund starker Kompression und mathematischer anstatt grafischer Beschreibung von Kurven, Linien etc. auch bei viel Inhalt nur sehr wenig Speicherplatz benötigt, und eignet sich ideal für das Internet mit seiner beDYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Einleitung
11
schränkten Bandbreite. Von Animationen über Comics und interaktive Spiele bis hin zu Onlineshops lässt sich mit Flash alles realisieren, was im Internet benötigt wird. PHP ist eine serverseitige Sprache, deren verborgene Stärken dem Betrachter einer Webseite meistens entgehen, die jedoch nicht weniger wichtig als der sichtbare Teil einer Webseite ist. Ob es um Datenbankzugriffe oder komplexe Dateioperationen geht, PHP ist vor allem durch seine komfortable Syntax und sein Funktionsrepertoire eine mächtige Sprache für die serverseitige Programmierung. Flash und PHP sind zwei vollkommen unterschiedliche Sprachen. Verbunden und sich gegenseitig ergänzend schaffen sie Raum für neue, ungeahnte Möglichkeiten. Ob man nun einen einfachen Besucherzähler benötigt (siehe Kapitel 5.5), ein Feedback-Formular (siehe Kapitel 3.3) , zeitgenaue Statistiken (siehe Kapitel 11.3) oder einen interaktiven Onlineshop (siehe Anhang A.1) in Flash bleibt kein Wunsch offen. So einfach dies klingt, so schwierig ist es, dies in der Praxis umzusetzen. Dieses Buch soll Ihnen einen Eindruck davon vermitteln, was mit Flash und PHP alles möglich ist. Anhand von Beispielen werden die Vorgehensweise bei häufigen Problemen erläutert und Lösungsmöglichkeiten aufgezeigt. Mit Hilfe dieses Buches sollte es Ihnen möglich sein, alle Hürden beim Umgang mit Flash und PHP zu überwinden. Ich werde so ausführlich wie möglich auf vorhandenen Code eingehen und zusätzliche Erklärungen geben. Allerdings sind beide Sprachen, sowohl PHP wie auch Flash, keine sehr kleinen Sprachen, und es ist unmöglich, im Rahmen dieses Buches auf alle Sprachkonstrukte im Einzelnen einzugehen. Deshalb sind zum gänzlichen Verständnis dieses Buches Grundkenntnisse von Flash und PHP erforderlich.
1.2.1 Danksagungen An dieser Stelle möchte ich denjenigen Personen danken, die mir beim Schreiben dieses Buches zur Seite standen: Ich danke Dominik Schech (www.schech.net) für den Entwurf des Covers, Jess Märtterer (www.de-de.de), der mir immer mit Rat und Tat zur Seite stand, Jochen Schimmelpfennig (www.onlinegeneration.com), der mir PHP zeigte, meinen Eltern Helmut Feth und Claudia Häfele-Feth für die mir gegebene Unterstützung, meiner Freundin Valerie Grass für ihre Geduld und Ausdauer und (in alphabetischer Reihenfolge) Sébastien Hordeaux, Christian Lamine, Johannes P., pi, Tobias Ratschiller, Marco Stix, Bastian Waidelich und Christian Wenz.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
12
Kapitel 1
1.2.2 Formales · Kommentare:
Im Folgenden sind oftmals Teile von Code aus Flash und aus PHP zu sehen. Für diese gilt im Allgemeinen: //~ einzeiliger Autorenkommentar /*~ mehrzeiliger Autorenkommentar */ • ActionScript-Code in Flash wird so eingeleitet: //~ ActionScript • PHP-Code wird so eingeleitet: • Funktionsdefinitionen: typ function name(typ parameter1 [, typ parameter2]) Der Parameter in eckigen Klammern ist ein optionaler Parameter mit einem voreingestellten Wert, der übergeben wird, wenn dieser Parameter (oben ist es Parameter 2) nicht angegeben wird. Sowohl in Flash als auch in PHP gibt es keine Typunterscheidung von Variablen, wie man sie z.B. aus C/C++ kennt, jedoch zeigt der Typ eines Parameters zumindest an, welches Format der übergebene Parameter haben muss. Teilweise sind bei den Funktionsdefinitionen die Original-Signaturen aus dem PHPManual übernommen worden. Ich danke an dieser Stelle noch einmal ausdrücklich der PHP Documentation Group, die freundlicherweise die Erlaubnis erteilt hat. • Farben: Alle Konstanten, vordefinierten Variablen, Befehle, Funktionen und reservierten Wörter sind eingefärbt. Dieses Symbol verweist auf Daten auf der Buch-CD.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
KAPITEL 2
GRUNDLEGENDES ZU PHP
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
14
Kapitel 2
2.1 Über PHP Die Scriptsprache PHP wurde 1994 von Rasmus Lerdorf (www.lerdorf.com) entwickelt. Er nannte seine Sprache PHP (»Personal Home Page/Form Interpreter«), da er sie für seine eigene Homepage verwendete, um HTML-Formulare auszuwerten. Mittlerweile verbirgt sich hinter der Abkürzung PHP der lange Name »PHP Hypertext Preprocessor«. PHP ist eine serverseitige, plattformunabhängige Scriptsprache und für alle gängigen Plattformen frei erhältlich. PHP bringt schon von Haus aus eine sehr gute Datenbankanbindung an die meisten gängigen Datenbanken mit, was den Umgang mit Daten aus Datenbanken extrem erleichtert. Weiterhin ist PHP sehr gut durch Module und Klassen erweiterbar, die im Internet oftmals frei erhältlich sind. Im Gegensatz zu anderen Scriptsprachen wie z.B. Perl ist vor allem die Handhabung von Variablen, die aus Formularen oder anderen externen Quellen (wie z.B. auch Flash) stammen in PHP sehr komfortabel. Es ist anders als in Perl möglich, auch ohne CGI.pm oder entsprechende Module auf die übergebenen Daten sofort zuzugreifen. Die Syntax von PHP erinnert etwas an die von C und ist relativ leicht erlernbar. PHP-Dateien können sowohl normalen HTML-Code als auch PHP-Anweisungen enthalten. Bei einem Abruf eines PHP-Scripts über den Browser wird zunächst der PHP-Code ausgeführt. Dem Browser wird anschließend die vorverarbeitete (daher der Name »Preprocessor«) Datei, d.h. nur die HTML-Anteile und die »Ergebnisse« der PHP-Anweisungen, übermittelt. Diese Übersetzung findet vollständig auf der Seite des Servers statt. Die eigentlichen PHPAnweisungen werden nicht übermittelt. Bei Flash ist dies ganz anders. Die in Flash verwendete Sprache »ActionScript«, häufig mit AS abgekürzt, wird auf der Clientseite ausgeführt, d.h. sämtliche AS-Anweisungen werden ebenso wie die anderen Steuerinformationen eines Flash-Filmes innerhalb der SWFDatei kodiert gespeichert und mit an das Flash-Plugin des Browsers übertragen. Das Flash-Plugin ist dann nicht nur für das Abspielen aller Animationen verantwortlich, sondern auch für die Interpretation und Ausführung der ActionScript-Anweisungen. Dadurch ist es in gewissem Maße möglich, dass ein Flash-Film sofort mit AS auf Benutzereingaben reagieren kann, ohne erneut Verbindung zum Server aufnehmen zu müssen (z.B. für interaktive Menüs oder Spiele). Bei PHP-basierten Anwendungen hingegen muss jedes Mal, wenn Benutzereingaben verarbeitet werden sollen, erneut eine Verbindung zum Server aufgebaut werden, d. h. eine PHP-Datei ausgeführt werden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Grundlegendes zu PHP
15
WAMP und LAMP Im Internet finden Sie im Zusammenhang mit PHP oft die Abkürzungen WAMP und LAMP. Exkurs
• LAMP steht für die Kombination von: Linux, Apache, MySQL und PHP. • WAMP steht für: Windows, Apache, MySQL und PHP. Dabei handelt es sich um Konfigurationen. Übrigens lassen sich auch andere bekannte Webserver wie z.B. der IIS von Microsoft mit einer PHP-Erweiterung betreiben. Genauso lassen sich andere Datenbanksysteme gut in Kombination mit PHP verwenden. LAMP und WAMP sind recht häufig verwendete Server-Konfigurationen. Sämtliche in diesem Buch behandelten Beispiele laufen ohne Probleme in beiden Umgebungen.
2.2 Bezugsquellen für PHP Verschiedene PHP-Distributionen finden Sie auf der CD-ROM im Verzeichnis Software und Module\PHP\. Die aktuellen PHP-Distributionen sind unter www.php.net für verschiedene Plattformen frei erhältlich. Eine Distribution speziell für Windows inklusive einiger vorkompilierter Module, die in der Distribution von www.php.net nicht enthalten sind (z.B. Ming), ist unter www. php4win.com verfügbar.
2.3 Installation von PHP Eine Installationsanleitung für WAMP gibt es unter: www.pc-town.de/praxis_wissen/workshops/php_mysql/wamp.php oder hier (auch für andere Betriebssysteme als Windows, z.B. LAMP): www.dynamic-webpages.de/07.installation.php Ich kann an dieser Stelle leider keine Installationsanleitung für PHP geben – zum einen aus Platzgründen, zum anderen, weil ich voraussetze, dass Sie sich als Leser dieses Buches bereits ein wenig mit PHP auskennen. Sollten Sie aber dennoch Unterstützung bei der Installation benötigen, schauen Sie im Verzeichnis Software und Module\PHP\Installation DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
16
Kapitel 2
der beiliegenden Buch-CD nach. Hier hat der herausgebende Verlag Markt+Technik die ersten vier Kapitel des Titels »Jetzt lerne ich MySQL & PHP« (ISBN 3-8272-6202-X) im PDFFormat zur Verfügung gestellt. Diese Kapitel sollten Sie sicher und einfach durch den Installationsprozess geleiten.
2.4 Einsatz der Skripte aus diesem Buch Sie können die Scripts entweder sofort online auf einem Server testen, der PHP unterstützt, oder lokal auf dem eigenen Rechner, der dann den Server darstellt. Um den eigenen Rechner zum Server zu machen, müssen Sie einen so genannten Webserver installieren. Mit diesem Webserver als Basis kann dann PHP installiert werden. Ich persönlich empfehle hier Apache (www.apache.org). ·
HINWEIS
Wenn Sie Ihre Scripts online testen bzw. einsetzen, müssen Sie beachten, dass es auf Servern, bei denen der SAFE MODE von PHP aktiviert ist, einige Einschränkungen gibt. Ob auf Ihrem Server der SAFE MODE aktiviert ist, kann Ihnen Ihr ISP bzw. dessen Administrator mitteilen.
Damit Sie als Leser dieses Buches meine und Ihre Programmcodes von derlei Einschränkungen unbeeinträchtigt austesten können, stellt Ihnen der Kölner Internet-Provider Host Europe (www.host-europe.de) in Kooperation mit dem herausgebenden Verlag Markt+ Technik von Mai 2002 an für die Dauer eines Jahres einen kostenlosen Webspace-Account zur Verfügung. Um dieses Angebot nutzen zu können, müssen Sie sich als Leser dieses Buches registrieren lassen. Füllen Sie hierzu das Formular unter buch.flashtool.de aus – ich richte Ihnen darauf hin Ihren Account ein und maile Ihnen Benutzerkennung, Passwort sowie die Richtlinien zur Nutzung des Angebots zu. Mein herzliches Dankeschön an Host Europe für die Bereitstellung des Dedicated Servers!
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
KAPITEL 3
DYNAMISCHE INHALTE
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
18
Kapitel 3
In diesem Kapitel zeige ich Ihnen die grundlegenden Möglichkeiten zum Austausch von Daten zwischen Flash und PHP. Zu jedem Beispiel finden Sie jeweils auch eine kleine Funktionsreferenz.
3.1 Variablen von PHP in Flash laden In diesem Kapitel wird gezeigt, wie sich Daten aus PHP in Flash-Filme übertragen (einlesen) und dort auswerten bzw. darstellen lassen.
3.1.1 Schema der Übergabe
Abbildung 3.1: Schema der Übergabe von Daten aus PHP an Flash. Mit den Befehlen loadVariables() oder loadVariablesNum()wird aus dem Flash-Film das Script aufgerufen und werden die vom Script ausgegebenen Daten empfangen. Auf die Flash-kompatible Formatierung von Daten wird in Kapitel 3.1.3 eingegangen.
3.1.2 Funktionen für das Laden Um Daten von PHP nach Flash zu laden, werden in Flash einige Funktionen benötigt. Diese werden in diesem Abschnitt vorgestellt. Außerdem werden einige häufige Fehler beim Umgang mit diesen Funktionen angesprochen. ·
HINWEIS
Die nachfolgend beschriebene Funktion loadVariables() und loadVariablesNum() sind asynchrone Prozesse. Das bedeutet, dass bei ihrem Aufruf die Timeline keinesfalls anhält und auf den Abschluss des Befehls wartet, sondern dass die Timeline sich ohne anzuhalten weiterbewegt. Es kann also nicht davon ausgegangen werden, dass im Schlüsselbild, das auf den Befehl folgt, die Daten bereits verfügbar sind. Die Verfügbarkeit von Daten muss zuerst überprüft werden. Mehr dazu in Kapitel 3.1.8.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
19
loadVariablesNum() Beschreibung: Mit loadVariablesNum() können Daten aus externen Datenquellen auf Ebenen im SWF geladen werden. Definition:
void loadVariablesNum (string url, string position [, int methode]);
Parameter:
string url Ein absoluter oder relativer URL zu dem Script, das aufgerufen werden soll. URL – URL steht für Uniform Resource Locator und ist die Abkürzung für eine Internetadresse. ·
HINWEIS
Ob der URL nun ein PHP-Script, ein ASP-Script, ein Perl-Script oder eine einfache Textdatei ist, macht keinen Unterschied, solange die Daten korrekt formatiert sind. Wie eine korrekte Formatierung aussieht, wird in Kapitel 3.1.3 erläutert. Seit Version 4.0.1.2 von Flash muss der angegebene URL auf demselben Host sein wie das SWF, von dem aus der Aufruf erfolgt (siehe Kapitel 5.1).
SWF – SWF ist die Abkürzung für ShockWave Flash. SWF wird aber meistens dazu verwendet, einen mit Flash erstellten Film zu benennen, da die Dateiendung .swf ist. string position Eine Ebene in unserem SWF. int methode Dieses Argument ist optional. Es gibt an, wie die in Flash vorhandenen Variablen an den URL gesendet werden. Mögliche Werte sind POST oder GET. Auf die verschiedenen Methoden wird in Kapitel 3.2.3 näher eingegangen. Anwendung:
Um die Ausgabe eines Scripts (hier: meinScript.php) auf Ebene 0 unseres Films zu laden, muss der Aufruf folgendermaßen aussehen: //~ ActionScript loadVariablesNum("meinScript.php", 0); ·
HINWEIS
Andere Betriebssysteme als Windows (z.B. Linux) unterscheiden zwischen Groß- und Kleinschreibung. Deshalb ist es wichtig, dass die Schreibweise des Scriptnamens bei einem Aufruf aus Flash mit dem wirklichen Namen der Datei übereinstimmt. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
20
Kapitel 3
loadVariables() Beschreibung: Mit loadVariables() können Daten aus externen Quellen auf Ebenen oder in Filmsequenzen geladen werden. Definition:
void loadVariables (string url , string position [, int methode]);
Parameter:
string url Ein absoluter oder relativer URL zu dem Script, das aufgerufen werden soll. string position Die Position ist hier ein Ziel innerhalb des SWF, beispielsweise eine Filmsequenz oder eine Ebene. int methode Dieses Argument ist optional. Es gibt an, wie die in Flash vorhandenen Variablen an den URL gesendet werden. Mögliche Werte sind POST oder GET. Auf die verschiedenen Methoden wird in Kapitel 3.2.3 näher eingegangen.
Anwendung:
Um die Ausgabe eines Scripts (hier: meinScript.php) in eine Filmsequenz auf unserer Hauptzeitleiste zu laden, muss der Aufruf des SWF folgendermaßen aussehen: //~ ActionScript loadVariables("meinScript.php", "_root.movieClip"); oder //~ ActionScript _root.movieClip.loadVariables("meinScript.php");
3.1.3 Korrekte Formatierung Damit Flash die Ausgabe eines Scripts richtig interpretieren kann, müssen die Daten eine bestimmte Form haben (application/x-www-form-urlencoded): variablenName=variablenWert Bei mehreren Variablen sieht dies so aus: variable1=wert1&variable2=wert2,...,&variableN=wertN Als Trennzeichen zwischen den einzelnen Variablen dient das &-Zeichen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
·
21
Der Inhalt des PHP-Scripts (hier: meinScript.php) ist folgender: echo() gibt einen String auf der Standardausgabe (Bildschirm bzw. Browser) aus. In Flash lädt folgender Code das PHP-Script mit oben stehendem Inhalt: //~ ActionScript loadVariablesNum("meinScript.php", 0); Wenn die Daten geladen wurden, dann sind sie an der Stelle verfügbar, die bei den Befehlen als Ziel angegeben wurde. Das heißt, die Variablen variable1 und variable2 sind jetzt auf der Hauptzeitleiste verfügbar und können beispielsweise als _root.variable1 _root.variable2
BEISPIEL
angesprochen oder in einem Textfeld auf der Hauptzeitleiste mit dem Namen variable1 oder variable2 angezeigt werden.
Einleitung und Schluss der Daten Flash lädt Daten normalerweise korrekt, wenn man bei der ersten Variable das &-Zeichen weglässt. Beispielsweise so: variable1=wert&variable2=wert Sollte das Script jedoch davor etwas anderes ausgeben (beispielsweise eine Warnung o. Ä.), dann wird der erste Variablenname durch die Ausgabe der Warnung verfälscht. ·
Wenn vor der Ausgabe der eigentlichen Daten ungewollt eine Warnung ausgegeben wird, z.B. so: UNGEWOLLTE_WARNUNGvariable1=wert&variable2=wert Dann wird in diesem Fall die erste Variable nicht mehr Variable variable1 = "wert" lauten, sondern: Variable UNGEWOLLTE_WARNUNGvariable1 = "wert" Dieses Problem kann man umgehen, indem man vor den Namen der ersten Variable auch ein &-Zeichen setzt; folglich so:
BEISPIEL
UNGEWOLLTE_WARNUNG&variable1=wert&variable2=wert
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
22
Kapitel 3
Es werden nun z.B. bei der Ausgabe eines Fehlers zwar trotzdem noch mehr (unnötige) Daten geladen, jedoch wird an den übergebenen Variablen nichts verfälscht. Leiten Sie Ihre Daten also immer mit einem &-Zeichen ein. Dasselbe gilt auch für das Ende der Daten. Wenn eine Warnung o. Ä. am Ende ausgegeben wird, dann wird diese an den Wert der letzten Variable angehängt. ·
Die Ausgabe eines Scripts enthält nach der Ausgabe der Daten eine ungewollte Warnung: &variable1=wert&variable2=wertUNGEWOLLTE_WARNUNG Wenn dies in Flash geladen wird, dann ist der Wert der Variable »variable2« nicht mehr Variable variable2 = "wert" sondern: Variable variable2 = "wertUNGEWOLLTE_WARNUNG" Es ist also sinnvoll, auch an das Ende der Daten ein &-Zeichen anzuhängen. Etwa so:
BEISPIEL
&variable1=wert&variable2=wert&UNGEWOLLTE_WARNUNG
Die Warnung wird zwar trotzdem noch geladen, allerdings wird sie nicht an den Wert der letzten Variable angehängt. Beenden Sie Ihre Datenausgabe also ebenfalls immer mit einem &-Zeichen. ·
HINWEIS
Bei Verwendung eines &-Zeichens am Ende wird in Flash eine überflüssige Variable mit leerem Namen geladen (wenn danach nichts mehr kommt), da das &-Zeichen ja normalerweise dafür verwendet wird, eine neue Variable einzuleiten. Wenn Sie diese Variable stört, so können Sie sie beruhigt löschen.
Auf diese Variable können Sie mit \r\n oder \n zugreifen (je nachdem wie Sie diese aus PHP ausgeben). Entsprechend lautet der Befehl, um diese Variable zu entfernen: delete \r\n; oder: delete \n; Dies erzeugt in der Flash-Entwicklungsumgebung eine Fehlermeldung; die Variable wird aber korrekt entfernt.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
23
Strukturierte Datenausgabe Dasselbe gilt auch, wenn man seine Ausgabe strukturieren möchte, um einen besseren Überblick zu bekommen. Falls Sie die Ausgabe etwa so schreiben wollen &preis1=25 &preis2=40 &preis3=80 dann werden Sie nach jedem Wert noch die Zeichen \r\n finden, so genannte Whitespaces (unter Whitespaces werden alle nicht sichtbaren Zeichen wie z.B. Space, Tab, Newline und Carriage Return verstanden). Um dies zu umgehen, müssen Sie hinter jedem Wert ein &Zeichen anbringen: &preis1=25& &preis2=40& &preis3=80& Solange die Werte nicht angezeigt werden, bemerkt man Whitespaces nicht. Es scheint einerlei zu sein, ob sie da sind oder nicht – will man jedoch mit den Werten rechnen, wie z.B. mit den Preisen im oberen Beispiel, so muss man sichergehen, dass keine Whitespaces vorhanden sind, sonst schlägt die Rechenoperation fehl.
Rechnen mit eingelesenen Werten Noch eine weitere Besonderheit muss man beachten, wenn man mit eingelesenen Werten rechnen möchte: Im englischsprachigen Raum ist bei der Angabe von Preisen der Punkt das Äquivalent des Kommas im deutschsprachigen Raum. Englische Angabe: 9.99 € Deutsche Angabe: 9,99 € Wenn Sie nun Preise (z.B. bei einem Onlineshop) im deutschen Format übergeben, dann können Sie mit diesen nicht rechnen, da sie nicht als Zahl, sondern als String erkannt werden. Wollen Sie mit eingelesenen Zahlen rechnen, muss die Ausgabe folgendermaßen aussehen: &preis1=9.99&preis2=18.07& Nicht: &preis1=9,99&preis2=18,07&
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
24
Kapitel 3
Leerzeichen Leerzeichen zwischen dem Variablennamen und dem Gleichheitszeichen werden an den Variablennamen angehängt. ·
Die Ausgabe eines PHP-Scripts ist folgende: &variable1
=wert
Sie sehen, dass zwischen variable1 und dem Gleichheitszeichen Leerzeichen sind. Diese werden von Flash nicht etwa ignoriert, sondern an den Variablennamen (in diesem Fall variable1) angehängt. Der Name ist also nicht mehr: Variable variable1 = "wert" sondern: Variable variable1 BEISPIEL
= "wert"
Sie sollten demnach keinen ungewollten Abstand setzen.
Übergabe von booleschen Werten Bei der Übergabe von booleschen Werten, also true (wahr) oder false (falsch) müssen Sie beachten, dass bei folgender Schreibweise: &variable1=true&variable2=false& die Werte von Flash als String angesehen werden. Um zu überprüfen, ob diese Variablen die richtigen Werte haben, müssten Sie folgenden Code benutzen: //~ ActionScript if (variable1 == "true" && variable2 == "false") { //~ Bedingung erfüllt } //~ end if Hier wird überprüft, ob der Wert der variable1 gleich dem String »true« ist und ob der Wert der variable2 gleich dem String »false« ist. Sie sehen, dass die Werte in diesem Falle Strings sind, keine booleschen Werte. Die richtige Formatierung, um einen Vergleich mit booleschen Werten zuzulassen, ist: &variable1=1&variable2=0&
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
25
Dieses Format erzielt das gewünschte Ergebnis: //~ ActionScript //~ prüfen, ob variable1 wahr und variable2 falsch ist if (variable1 && !variable2) { //~ Bedingung erfüllt } //~ end if Diese Abfrage prüft, ob variable1 true (wahr) und variable2 false (falsch) ist.
URL-Kodierung von Werten Dieses Beispiel befindet sich im Ordner Applikationen\urlEncode\ auf der CD-ROM. Da bei der Übergabe von Daten nur ein bestimmter Zeichensatz erlaubt ist, müssen alle Zeichen, die nicht alphanumerisch sind (bis auf -_. ), in % gefolgt von dem ASCII-Code des Zeichens umgewandelt werden. Dies ist vor allem bei den &-Zeichen wichtig, die als Trennzeichen für Variablen fungieren. So führt &menue=Fish & Chips& nicht zu einer Variable menue mit dem Wert Fish & Chips innerhalb von Flash, sondern zu zwei Variablen: zu einer mit dem Namen menue und dem Wert Fish und zu einer mit dem Namen Chips und einem leeren Wert: Variable menue = "Fish " Variable Chips = "" Sie sehen, dass das zweite &-Zeichen ungewollt eine neue Variable einleitet, obwohl es eigentlich ein Teil vom Wert der Variable menue sein sollte. Um das gewünschte Ergebnis zu erzielen, ist folgende Formatierung korrekt: &menue=Fish+%26+Chips& Dies ergibt nach dem Laden in Flash folgende Variable: Variable menue = "Fish & Chips"
Die Funktion urlencode() Damit man nicht alles von Hand kodieren muss, gibt es in PHP die Funktion urlencode(), welche die Daten in das korrekte Format bringt. Tutorial
string urlencode (string str) string str Das Argument ist der String, der kodiert werden soll. Zurückgegeben wird ein String im kodierten (richtigen) Format.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
26
Kapitel 3
Beispiel: Der Code gibt auf dem Bildschirm &menue=Fish+%26+Chips& aus, was von Flash korrekt interpretiert wird. Beim Kodieren muss man unbedingt darauf achten, die als Trennzeichen fungierenden &-Zeichen nicht mit zu kodieren, da man sonst einen einzigen riesigen String bekommt, der von Flash nicht richtig verstanden wird. Beispiel: Der Code ergibt die Ausgabe: %26menue1%3DFish+%26+Chips%26menue2%3DBeef%26 Sie sehen, dass jetzt zwar die Zeichen URL-kodiert wurden, die man kodieren wollte, aber auch alle &-Zeichen, die zum Einleiten der Variablen benötigt werden, und alle Gleichheitszeichen ebenfalls. Diese Ausgabe kann von Flash nicht mehr korrekt interpretiert werden. Kodieren Sie also, wie oben beschrieben, immer nur den Wert einer Variablen, nie die gesamten Daten.
Sonderzeichen
ASCII-Wert
Sonderzeichen
& % # Ü ü Ä
%26 %25 %23 %DC %FC %C4
ä Ö ö ß Zeilenumbruch (\n) Leerzeichen
Tabelle 3.1: Wichtige ASCII-Werte von Sonderzeichen
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
ASCII-Wert %E4 %D6 %F6 %DF %0D %20
Dynamische Inhalte
27
Die in Tabelle 3.1 stehenden ASCII-Werte von Sonderzeichen erhalten Sie bei der Benutzung von urlencode() automatisch. Jedoch halte ich es für sinnvoll, häufig verwendete Zeichen hier anzuführen, damit diese auch ohne PHP (z.B. nur mit Textdateien) eingesetzt werden können. ·
HINWEIS
Bei der Verwendung von Sonderzeichen wie ü, Ü, ä, Ä, ö, Ö und ß sollten die Zeichen selbst bei einer häufigen Schriftart im Textfeld (in Flash) mit eingebunden werden, da sie in den Schriftsätzen anderer Länder oftmals nicht enthalten sind.
Übergabe von relativen Pfadangaben Dieses Beispiel befindet sich im Ordner: Beispiele\redoPath\ auf der CD-ROM. Wenn man in ein SWF dynamisch andere SWF laden möchte (z.B. weil man ein Bild jede Woche ändert etc.), dann kann es sein, dass bei der Übergabe der Pfade für die externen SWF ein Pfad dabei ist, der relativ auf ein Verzeichnis über dem Hauptfilm zeigt. Da die Ein- und Ausgabe von Daten in Flash auch immer etwas mit dem Browser zu tun hat, gibt es bei der Übergabe von relativen Pfaden weitere, browserbedingte Probleme. Dies liegt daran, dass ja nicht direkt mit dem Flash-Plugin gesurft wird, sondern über Umwege. Die Daten, die vom Server kommen, werden vom Browser angenommen und dann erst an das Flash-Plugin weitergeleitet. Das heißt, bei der Kommunikation zwischen Browser und Plugin können Probleme auftreten. Dies ist auch hier der Fall. Da diese Probleme sehr selten und sehr sporadisch auftreten, lassen sich an dieser Stelle keine genauen Versionsnummern der Browser nennen. Sicher ist, dass im Netscape 4.x Probleme auftreten können. Erfahrungswerte mit dem Netscape 6.x habe ich noch keine. Im Internet Explorer habe ich noch keine bemerkt, aber auch hier sind Fehler nicht grundsätzlich auszuschließen. Im Netscape 4.x bringt folgende Ausgabe bzw. deren Laden in Flash oftmals nicht das gewünschte Ergebnis: &pfad=../bild.swf& Netscape versucht, die Pfadangabe schon vor dem Eintreffen in Flash zu interpretieren. Das bedeutet, dass bei der Übergabe von Pfaden zwischen dem Browser (Netscape) und dem Plugin ein Fehler auftritt, da der Pfad nicht mehr korrekt im SWF ankommt. Ich nehme an, dass Netscape an der entsprechenden Stelle nach dem Ziel sucht, anstatt die Pfadangabe einfach weiterzugeben. Abhilfe schafft hier eine Maskierung. Das heißt, man muss die auf die Unterverzeichnisse zielenden ../ in eine Zeichenfolge umwandeln, die Netscape nicht als Pfadangabe interpretiert. Dies wäre beispielsweise so etwas: &pfad=**/bild.swf&
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
28
Kapitel 3
Diese Umwandlung muss man dann innerhalb von Flash wieder rückgängig machen. Die folgende Funktion erledigt das für uns: //~ ActionScript function redoPath(myPath, splitChar) { //~ Alle splitChar in . umwandeln myPath = myPath.split(splitChar).join("."); return myPath; //~ Ergebnis zurückgeben } //~ end function redoPath pfad = redoPath(pfad, "*"); //~ Anwendung der Funktion Diese Funktion wandelt einen maskierten Pfad wieder in die richtige Form um. Aus **/bild.swf wird demnach ../bild.swf. Sie können selbstverständlich auch jedes andere Zeichen verwenden, um den Pfad zu maskieren. Allerdings sollte es ein Zeichen sein, das in der URL selbst nicht vorkommt und auch bei Pfadangaben im Pfad selbst nicht auftreten kann. Bestens geeignet wäre etwa *. · HINWEIS
Eine Maskierungsfunktion für Pfade ist Teil von flash.inc.php (siehe Kapitel 10).
3.1.4 Arrays von PHP nach Flash übergeben Arrays lassen mehr Möglichkeiten zur Strukturierung von Daten. Wenn Sie z.B. eine Liste übergeben möchten, dann können Sie dies selbstverständlich tun, indem Sie die Variablennamen mit Zahlen versehen, etwa so: &listenwert1=wert& &listenwert2=wert& &listenwert3=wert& Allerdings wird dies bei größeren Datenmengen erstens relativ unübersichtlich, und zweitens ist der Zugriff auf diese Art von Variablen nicht sonderlich komfortabel. Bei Daten, die alle zu einer Gruppe gehören, aber dennoch unterschieden werden müssen, setzt man normalerweise Arrays ein. Array – (deutsch: »Reihung«) Ein Array ist eine Liste von Elementen (Daten), die in einer, zwei oder mehreren Dimensionen gespeichert werden können. Im Folgenden werden zwei verschiedene Arten beschrieben, wie man ein Array an Flash übergibt. Eine Übergabe eines Arrays ist ursprünglich nicht vorgesehen, daher bilden die beiden beschriebenen Verfahren nur einen Kompromiss. Jedes der Verfahren hat sowohl Nachteile als auch Vorteile. Bei beiden Möglichkeiten lassen sich keine mehrdimensionalen Arrays übergeben.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
29
Erste Möglichkeit: mit Hilfe von join() und split Das Prinzip: Das Array in PHP wird zu einem String umgeformt, und dabei werden die einzelnen Arrayelemente z.B. durch Kommata getrennt. Dieser String wird dann an Flash übergeben. Dort kann anhand der Trennzeichen wieder ein Array gebildet werden. Der Vorteil dieser Methode ist, dass extrem wenige Daten übergeben werden und keine Funktion benötigt wird, welche die Daten (strukturierte Variablen) in eine andere (für Flash verständliche) Form bringt. Nachteile hingegen ergeben sich daraus, dass man keine assoziativen Arrays übergeben kann und dass man hundertprozentig sicher sein muss, dass das benutzte Trennzeichen nicht innerhalb der übergebenen Werte auftaucht, da sonst das Array falsch aufgebaut wird. ·
Ein PHP-Script hat folgenden Inhalt: Als Trennzeichen zwischen den Elementen werden Kommata verwendet. Der String, der nun ausgegeben wird, sieht so aus:
BEISPIEL
&arrayString=Keine Kommata erlaubt, Hier, sind, aber, trotzdem, welche&
Sie sehen, dass nicht nur zwischen den Elementen Kommata sind, sondern auch im Wert des zweiten Elements. Wenden Sie auf diesen String in Flash die split()-Funktion an, erhalten Sie nicht ein Array mit zwei Elementen, sondern ein Array mit sechs Elementen. Flash kann ja nicht erkennen, welche Kommata Trennzeichen sind und welche zum Wert gehören. Sie können natürlich in diesem Fall ein anderes Trennzeichen verwenden, z.B. einen *. Wenn dieser jedoch auch in einem Wert des Arrays vorkommt, haben wir wieder das gleiche Resultat. Sollten Sie also nicht hundertprozentig sicher gehen können, dann ist diese Methode ungeeignet. Verwenden Sie in diesem Fall die zweite Methode!
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
30
Kapitel 3
Das Beispiel befindet sich im Ordner Beispiele\arrayStuff\arraySplit\ auf der CD-ROM. Wenn Sie sich sicher sind, dass Sie wissen, welche Zeichen in den Werten auftauchen und welche nicht, dann können Sie diese Methode ohne weiteres anwenden. ·
Ein PHP-Script hat folgenden Inhalt:
= array(); //~ neues Array erstellen
$nameArray[0] $nameArray[1] $nameArray[2] $nameArray[3] $nameArray[4]
= = = = =
"Joscha"; "Hans"; "Peter"; "Hannes"; "Markus";
//~ In kommaseparierte Liste umwandeln. $arrayString = join(",", $nameArray); //~ Ausgeben echo "&arrayString=".$arrayString."&"; BEISPIEL
?>
Als Erstes wird das Array erstellt, das an Flash übergeben werden soll. In unserem Fall eine Namensliste. Dieses Array wird mit join() in eine kommaseparierte Liste umgewandelt. Dieser String wird dann ausgegeben.
Die Funktion join() string join (string glue, array pieces) join() wandelt Arrays in Strings mit Trennzeichen um. Tutorial
string glue Das erste Argument ist der String, mit dem die verschiedenen Elemente getrennt werden. array pieces Das zweite Argument ist das Array, das in einen String umgewandelt werden soll. Zurückgegeben wird das in einen String umgeformte Array mit dem gewählten Trennzeichen zwischen den einzelnen Elementen.
In diesem Fall wurde als Trennzeichen ein Komma gewählt, da keiner der Namen ein Komma enthält und so in Flash korrekt gesplittet werden kann. Wenn Sie wissen, welche Zeichen das Array enthält, und so ein Trennzeichen wählen können, das nicht in dem Array vorkommt, dann ist diese Methode gut geeignet.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
31
Wenn Sie jedoch nicht wissen, was für Zeichen im Array vorkommen, dann sind Fehler vorprogrammiert – in diesem Fall wird dringend zur zweiten Methode geraten, oder Sie müssen das gewählte Trennzeichen in den Daten URL-kodieren (siehe Kapitel 3.1.3). Dies geht allerdings nur, wenn Sie ein Trennzeichen wählen, das nicht alphanumerisch ist (wie z.B. ein Komma). Der ausgegebene String sieht nun so aus: &arrayString=Joscha,Hans,Peter,Hannes,Markus& Das SWF bzw. der Code, um das Array wieder aufzubauen, sieht so aus:
Abbildung 3.2: Das zu einer kommaseparierten Liste zusammengesetzte Array wird geladen und dann per split() wieder in ein Array umgeformt. Danach wird der geladene String gelöscht.
Wenn ein Element leer sein soll, so genügt es nicht, dieses Element in PHP einfach nicht zu deklarieren. Etwa so:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
32
Kapitel 3
Es »fehlen« die Elemente 5 und 6 des Arrays $nameArray, denn der String, der nun ausgegeben würde, wäre folgender: &arrayString=Joscha,Hans,Peter,Hannes,Markus,Daniel& Sie sehen, dass obwohl zwischen den Elementen 4 und 7 eine »Lücke« ist, diese im String nicht ausgedrückt wird. Dies mag teilweise geschickt sein; wenn man jedoch die Positionen der Elemente bei der Übergabe berücksichtigen möchte, müssen fehlende Elemente als »leer« deklariert werden. Etwa so:
= = = = = = = =
"Joscha"; "Hans"; "Peter"; "Hannes"; "Markus"; ""; ""; "Daniel";
//~ Hier Code zum Ausgeben ?> Ausgegeben würde dann: &arrayString=Joscha,Hans,Peter,Hannes,Markus,,,Daniel& Der String unterscheidet sich nur geringfügig von dem anderen, leere Positionen sind bei ihm jedoch berücksichtigt. Wenn Sie nicht genau wissen, welche Elemente leer sind, dann können Sie folgende Funktion verwenden, um fehlende Elemente in Arrays zu deklarieren:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
33
Diese Funktion fügt »fehlende« Elemente in ein Array ein und sortiert es anhand der Schlüssel. · HINWEIS
Diese Funktion inklusive URL-Kodierung und direkter Flash-spezifischer Ausgabe ist Teil von flash.inc.php (siehe Kapitel 10).
Zweite Möglichkeit: Parsen der Arrays Dieses Beispiel befindet sich im Ordner Beispiele\arrayStuff\arrayParse\ auf der CD-ROM. Parser – (engl.: to parse = analysieren) Ein Parser analysiert Daten mit einer bestimmten Struktur (hier Variablen) und wandelt diese in eine andere Form (hier Arrays) um. Das Prinzip: Das Array in PHP wird in die Array-Schreibweise umgeformt (arrayName [key]=value) und dann an Flash übergeben. In Flash wird mit einem Parser das Array aus den einzelnen Strings aufgebaut. Der Vorteil dieser Methode ist, dass sich auch assoziative Arrays übergeben lassen und dass nicht darauf geachtet werden muss, welche Zeichen in den Daten vorhanden sind, da kein Trennzeichen benötigt wird. Diese Art der Übergabe ist jedoch etwas langsamer als die erste, da zum einen mehr Daten (Name des Arrays, Schlüssel und eckige Klammern) übergeben werden als bei der ersten Methode und zum anderen das Parsen an sich etwas mehr Zeit benötigt. ·
Ein PHP-Script hat folgenden Inhalt:
while(list($key,$value) = each($nameArray)) { echo "&nameArray[".$key."]=".$value."&\n"; } BEISPIEL
?>
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
34
Kapitel 3
Zuerst wird ein Array erstellt, das nicht nur numerische, sondern auch nicht-numerische Schlüssel enthält: also ein assoziatives Array. Dieses Array wird dann durchlaufen, und die einzelnen Elemente werden in der Form Arrayname[key]=value ausgegeben. · HINWEIS
Diese Funktion inklusive URL-Kodierung und direkter Flash-spezifischer Ausgabe ist Teil von flash.inc.php (siehe Kapitel 10).
Der ausgegebene String ist wäre in diesem Fall dann folgender: &nameArray[0]=Joscha& &nameArray[1]=Hans& &nameArray[2]=Peter& &nameArray[3]=Hannes& &nameArray[4]=Markus& &nameArray[7]=Daniel& &nameArray[key]=value& Flash kann mit diesen Daten direkt noch nichts anfangen, da sie als normale Variablen interpretiert werden. Die Daten sind also im Flash-Film vorhanden, jedoch lassen sie sich nur als Variablen und nicht als Array ansprechen. Wir müssen die Daten also noch in »richtige« Arrays umformen. Die dazu notwendigen Funktionen bzw. Prototypen sind relativ komplex und werden an dieser Stelle nicht näher behandelt. Sie sind auf der CD-ROM beigelegt und können selbstverständlich angepasst und verändert werden. Uns interessiert an dieser Stelle nur ihre Benutzung. Wenn man also die Daten geladen hat, dann muss man eine Funktion ausführen. Ihr Name ist buildArrays(). Wichtig ist, dass buildArrays() ein Filmsequenz-Prototyp ist, d.h. der Aufruf muss: //~ ActionScript myClip.buildArrays(); lauten. Sollte man die Daten nicht in eine Filmsequenz geladen haben, sondern auf eine Ebene, dann sieht der Aufruf so aus: //~ ActionScript _root.buildArrays(); So muss der Aufruf lauten, wenn die Daten auf Ebene 0 geladen wurden. Wenn die Daten auf Ebene 2 geladen wurden, lautet der Aufruf hingegen: //~ ActionScript _level2.buildArrays(); Die Funktion erstellt aus den »falschen« Arrays ein richtiges Array und löscht die alten Variablen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
·
HINWEIS
35
Je nach Menge der übergebenen Variablen dauert das Parsen einige Zeit. Beschleunigen kann man das, indem man Arraydaten in eine leere Filmsequenz lädt und nur dort parst. Bei einem Aufruf an einer Stelle, wo schon andere Variablen deklariert wurden, werden auch diese durchlaufen, um zu sehen, ob sie eventuell Arrays sein könnten. Dies dauert unnötig Zeit. Bei der Übergabe von Arrays mit mehr als 50 (!) Elementen kann es sein, dass der Flash-Film zu viele Aktionen ausführt und das Script abbricht. Deshalb sollte immer darauf geachtet werden, nicht zu viele Arrays bzw. Elemente auf einmal zu schicken. Eine Deklaration von Variablen in Flash, die das Zeichen [ oder ] enthalten, ist nicht möglich, bei eingeladenen Textdateien jedoch sehr wohl, daher kann zwischen Variablen und Variablen, die Arrays sein sollen, zu 100% unterschieden werden. Es ist also ohne weiteres möglich, in dem PHP-Script, in dem man Arrayvariablen verschickt, auch normale Variablen zu versenden oder in Flash bereits Variablen zu definieren, ohne dass es zu einer Verwechslung kommt.
Das Ergebnis in Flash nach dem Parsen ist also: Variable nameArray = [object #1] [ key:"value", 7:"Daniel", 4:"Markus", 3:"Hannes", 2:"Peter", 1:"Hans", 0:"Joscha" ] Sie sehen, dass bei dieser Methode nicht nur »leere« Elemente berücksichtigt werden, sondern auch, dass die Übergabe von assoziativen Arrays möglich ist. Beides ist bei der ersten Methode nicht so einfach zu erreichen, dafür müssen Sie die Verzögerung in Kauf nehmen, die das Parsen verursacht. Diese Verzögerung ist jedoch bei kleineren Arrays verschwindend gering.
3.1.5 Variablen innerhalb des - und <EMBED>-Tags an Flash übergeben Dieses Beispiel befindet sich im Ordner Beispiele\externVar\ auf der CD-ROM. Tag – (deutsch: Etikett) Ein Tag ist eine Kennzeichnung und wird zur Strukturierung von Daten (z.B. in HTML) verwendet. Hier leiten die beiden Tags ein in HTML eingebundenes SWF ein. Sie sagen quasi dem Browser, dass dieser Teil des Codes durch das FlashPlugin angezeigt wird. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
36
Kapitel 3
Es mag vorkommen, dass man einmal Variablen an SWF-Filme innerhalb einer HTMLSeite an Flash übergeben muss und aus bestimmten Gründen keinen loadVariables()oder loadVariablesNum()-Befehl verwenden kann oder möchte, um die Daten direkt zu laden. In diesem Fall gibt es die Möglichkeit, die Variablen innerhalb der HTML-Seite bzw. des PHP-Scripts direkt an das SWF zu übergeben. Jedoch ist Folgendes zu beachten: • Variablen werden ausschließlich auf Ebene 0 übergeben. • Die Übergabe schlägt bei Macintosh-Usern mit älteren Browsern eventuell fehl. Bei erneutem Laden der Seite funktioniert es meistens. Da diese Fehlfunktionen sehr sporadisch und nach keinem genauen Muster auftreten, können an dieser Stelle leider keine genauen Versionsnummern der Browser bzw. Flash-Plugins genannt werden. Ich habe mit sehr vielen aktuellen Browsern Tests durchgeführt und keine Probleme entdeckt. Es mag sein, dass diese in neueren Browserversionen behoben wurden. Bei dieser Art von Übergabe werden die Variablen etwa so angehängt: meinSWF.swf?variable1=wert&variable2=wert Jedoch werden die Variablen nicht an den URL der HTML-Seite angehängt, sondern innerhalb des HTML-Codes in die Tags für das SWF geschrieben. Das sieht dann folgendermaßen aus: <EMBED src="meinSWF.swf?variable=wert"> Die anderen Parameter der Tags können bzw. sollten selbstverständlich hinzugefügt werden, hier sind sie jedoch aus Gründen der Übersichtlichkeit weggelassen worden. Wichtig ist, dass die Variablen an das SWF sowohl im - als auch im <EMBED>-Tag angehängt werden müssen, sonst schlägt die Übergabe evtl. fehl. Sie könnten nun in einem PHP-Script verschiedene Variablen ermitteln oder Benutzereingaben verarbeiten und dann den Code für das SWF inklusive der angehängten Variablen ausgeben. Vergessen Sie auch bei dieser Übergabe nicht, die Werte zu URL-kodieren (siehe Kapitel 3.1.3). ·
Ein PHP-Script mit folgendem Code:
BEISPIEL
?>
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
·
37
BEISPIEL
übergibt an Flash bzw. an das SWF eine Variable variable.
Diese kann dort beispielsweise in einem Textfeld angezeigt werden. Dieses Textfeld muss ein dynamisches Textfeld sein und entweder auf Ebene 0 liegen und den Namen variable haben oder – sollte es nicht auf Ebene 0 liegen – den Namen _root.variable. ·
=$string?> ist eine Kurzform von .
HINWEIS
3.1.6 Caching-Verhalten Caching – (engl.: cache = Lager, Versteck) Im Cache eines Browsers werden Webseiten, Bilddateien etc. aus dem Internet gespeichert, um bei einem erneuten Aufruf derselben Seite die Daten nicht laden zu müssen, falls die Daten sich in der Zwischenzeit nicht verändert haben. Es ist möglich, dass der Browser bei mehrmaligem Aufruf eines PHPScripts aus Flash fälschlicherweise annimmt, die Datei bzw. deren Ausgabe habe sich nicht verändert und so den alten (noch gespeicherten) Inhalt lädt (siehe unten). Das Flash-Plugin übernimmt das Caching-Verhalten des jeweiligen Browsers, auf dem es installiert ist. Das heißt, zusätzlich zu dem SWF selbst werden Scripts, die aus Flash mit loadVariables() oder loadVariablesNum() geladen werden, im Cache des Browsers gespeichert. Dies kann bei mehrmaligen Aufrufen eines Scripts dazu führen, dass kein neuer Inhalt, sondern der Inhalt aus dem Browsercache geladen wird. Um dies zu umgehen, gibt es zwei Möglichkeiten: Man kann jede Möglichkeit sowohl einzeln einsetzen als auch beide Möglichkeiten kombinieren. Ich empfehle, wenn möglich beiDYNAMISCHE WEBSEITEN MIT FLASH UND PHP
38
Kapitel 3
des einzusetzen, und wenn hundertprozentig sichergestellt werden muss, dass keine Daten aus dem Browsercache geladen werden, die Lösung auf Flash-Seite. Die Lösung mit PHP kann fehlschlagen, sollte der Browser die versendeten Kopfzeilen falsch interpretieren.
Caching auf Flash-Seite verhindern Dieses Beispiel befindet sich auf der CD-ROM unter Beispiele\phpAvoidCache\phpAvoid Cache.fla. Um auf Flash-Seite das Caching zu verhindern, wird beim Aufruf von loadVariables(), loadVariablesNum() oder getURL()ein einmaliger Wert an den URL des Scripts angehängt, sodass der Browser bei jedem Aufruf annimmt, es sei ein neuer URL und deshalb die Daten neu lädt, ohne im Cache überhaupt nach (alten) gespeicherten Daten zu suchen. Diese Methode ist je nach angehängtem Wert sehr bis hundertprozentig sicher. ·
Oft werden im Internet Lösungen angeboten, die eine zufällig ermittelte Zahl anhängen, etwa so: //~ ActionScript //~ z.B.: loadVariablesNum("meinScript.php?"+Math.random(), 0); //~ oder:
BEISPIEL
loadVariables("meinScript.php?"+Math.random(), "_root");
Math.random() generiert eine Zahl zwischen 0,0 und 1,0 – diese wird an den URL (hier: meinScript.php) angehängt. Die Chance, dass sich die Zahl bei einem Aufruf mit demselben Browser wiederholt, ist sehr gering. Wenn die Zufallszahl nicht die erste Variable ist, die angehängt wird, dann muss sie mit einem &-Zeichen von den anderen Variablen getrennt werden, nicht mit einem Fragezeichen (?). Dies funktioniert; allerdings ist diese Lösung nicht hundertprozentig sicher, da die Zahl sich wiederholen kann. Zugegeben, die Wahrscheinlichkeit ist sehr klein, allerdings jedoch nicht ausgeschlossen. Deshalb empfehle ich eine Zahl, die sich wirklich nie wiederholt. Ein Timestamp beispielsweise wäre dazu perfekt geeignet: //~ ActionScript timeStamp = new Date().getTime(); loadVariables("meinScript.php?="+timeStamp, "_root"); Hier wird das aktuelle Datum angehängt. Die generierte Zahl ist einmalig und somit bestens dazu geeignet, ein zweites Laden zu verhindern.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
·
HINWEIS
39
Wenn Sie an den URL einen Wert anhängen, dann funktioniert dies nur aus dem Browser heraus, nicht offline aus dem Standalone-Player, da Flash dann nach einer Datei sucht, die den Namen des Scripts inklusive des Fragezeichens und der Nummer hat.
Caching mit PHP verhindern Dieses Beispiel befindet sich auf der CD-ROM unter Beispiele\phpAvoidCache\phpAvoid Cache.php. Um mit PHP das Caching zu verhindern, werden mit dem Header des Scripts bestimmte Informationen gesendet. Diese Funktion zu verwenden ist beim Umgang mit sensiblen Daten sinnvoll, damit nichtautorisierte Personen nicht aus dem Cache Dritter Daten entnehmen können. Ebenfalls wird so unterbunden, dass die Seiten von Proxies gespeichert werden. Header – (deutsch: »Kopfteil«) Ein Header ist der Anfangsteil eines zu übertragenden Datenpakets. Er enthält alle wichtigen Informationen über die folgenden Daten, wie z.B. Datentyp und -länge oder hier z.B. Caching-Informationen für Proxies und Browser. Proxyserver – (engl.: proxy = Vollmacht) Proxies dienen als Zwischenspeicher für Daten. Normalerweise wird ein Datenpaket vom Quellserver bis zum Client weitergegeben. Proxies speichern diese Daten zwischen, sodass beim nächsten Abruf derselben Information der Datenweg verkürzt werden kann.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
40
Kapitel 3
header("Cache-Control: post-check=0", false); header("Cache-Control: pre-check=0", false); //~ Anweisung für ältere Browser (HTTP/1.0), das Dokument nicht zu cachen header("Pragma: no-cache"); //~ hier der weitere PHP-Code ?> ·
Diese Funktion ist Teil von flash.inc.php (siehe Kapitel 10).
HINWEIS
Die Funktion header() int header(string string [, bool replace]) Der erste Parameter ist ein HTTP-Header in der Form: Tutorial
Variable: Anweisung1[=Wert] [,Anweisung2][=Wert] [...] Das bedeutet: Zuerst wird der Name des Headers gesendet (z.B. CacheControl). Nach dem Doppelpunkt folgt die erste Anweisung (z.B. max-age). Die weiteren Argumente sind optional. Das sind einerseits Werte für die Anweisung(en) oder weitere Anweisungen (durch Kommata separiert). Es können beliebig viele Anweisungen für eine Variable gesendet werden. Der zweite Parameter gibt an, ob ein bereits definierter Header des gleichen Typs ersetzt werden soll oder nicht. Wollen Sie mehrere Header desselben Typs, aber mit unterschiedlichen Anweisungen versenden, so müssen Sie als zweites Argument false angeben. Weitere Informationen zu Headern finden Sie unter: www.w3.org/Protocols/rfc2616/rfc2616.html Der Aufruf von header()-Funktionen muss immer vor jeglicher sonstiger Ausgabe geschehen. Sobald andere Daten gesendet wurden, ist es nicht mehr möglich, zusätzliche Header zu senden.
·
HINWEIS
Verschiedene Browser haben verschiedene Gewohnheiten (Bugs :-), somit ist die oben stehende Lösung nicht hundertprozentig sicher. Sie sollte nur zusammen mit der Lösung auf Flash-Seite eingesetzt werden, wenn absolute Zuverlässigkeit verlangt ist. Der Timestamp allein (in Flash) sollte schon hundertprozentige Sicherheit bieten.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
41
3.1.7 Beispiel: IP-Übergabe an Flash Dieses Beispiel befindet sich im Ordner Beispiele\getIP\ auf der CD-ROM. Unser Ziel ist es, in einem PHP-Script die IP-Adresse des Clients zu ermitteln, diese in Flash zu laden und dann anzuzeigen.
Abbildung 3.3: Aufbau einer SWF-Datei, in der mittels loadVariablesNum() die IP-Adresse des Clientrechners aus PHP in Flash geladen und in einem dynamischen Textfeld ip ausgegeben wird.
Inhalt des PHP-Scripts: Der Ablauf ist folgender: 1. Die IP-Adresse wird von PHP ermittelt, und dann wird das korrekt formatierte Ergebnis von Flash geladen. 2. In Flash wird die IP-Adresse in einem Textfeld angezeigt. Erstellung der Applikation: 1. Neue PHP-Datei erstellen (hier: getIP.php). 2. Um in PHP die IP-Adresse des Clientrechners zu erhalten, benutzen wir folgenden Code: $ip = getenv('REMOTE_ADDR');
Dieser Code holt die IP-Adresse des Clients aus den PHP-Umgebungsvariablen und weist ihn der Variable $ip zu.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
42
Kapitel 3
·
Die IP-Adresse wird beim Aufruf des PHP-Scripts sowohl als Umgebungsvariable (Erklärung siehe unten) wie auch als normale Variable behandelt (auf »normale« Variablen kann per $variable zugegriffen werden). Anders als Umgebungsvariablen sind normale Variablen veränderbar, hier wird eine Umgebungsvariable nur zusätzlich als »normale« Variable gespeichert, um einen einfacheren Zugriff auf sie zu gestatten. Anders als auf Umgebungsvariablen kann auf diese Variablen nicht mit getenv() zugegriffen werden. So führen getenv('REMOTE_ADDR') und $REMOTE_ADDR normalerweise zum selben Ergebnis, die Variable $REMOTE_ADDR kann jedoch innerhalb des PHP-Scripts (versehentlich) neu definiert werden, deshalb ist der getenv()Befehl vorzuziehen. Zusätzlich muss die Variable $REMOTE_ADDR bei Benutzung innerhalb von Funktionen erst mit global importiert werden. Es wird davon abgeraten, die Variable $REMOTE_IP zu verwenden, um die IP des Besuchers zu ermitteln, da diese Variable oftmals nur die IP-Adresse des Proxyservers enthält.
HINWEIS
Umgebungsvariable – (engl.: environment variable) Umgebungsvariablen sind Variablen, die von PHP beim Aufruf des Scripts automatisch festgelegt werden. Sie sind nicht veränderbar und man kann auf sie von überall her (aus Klassen, Funktionen etc.) per getenv('UMGEBUNGSVARIABLE'); zugreifen.
3. Als Nächstes müssen wir dafür sorgen, dass die IP-Adresse in ein Flash-kompatibles Format umgewandelt wird. Dies erledigen wir folgendermaßen: $ip = "&ip=".$ip."&"; Dieser Code wandelt die Ausgabe (hier die IP-Adresse) in ein für Flash lesbares Format um. 4. Nun müssen wir die korrekt formatierte Ausgabe (IP-Adresse) noch ausgeben: echo $ip; 5. Erstellen Sie nun einen neuen Flash-Film. 6. Im ersten Bild fügen Sie eine loadVariablesNum()-Aktion ein, die das eben erstellte Script (hier: getIP.php) auf Ebene 0 lädt. loadVariablesNum("getIP.php", 0); Dieser Befehl lädt das Script getIP.php auf Ebene 0. Als Aktion wurde hier weder GET noch POST angegeben, da keine Variablen aus Flash an PHP verschickt werden müssen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
43
7. Um die IP-Adresse anzuzeigen, muss nun noch ein dynamisches Textfeld erstellt werden, das auf Ebene 0 liegt und den Namen ip hat. ·
HINWEIS
Sollte das Textfeld auf einer anderen Ebene sein oder in einer Filmsequenz, dann muss entweder die Variable des Textfeldes angepasst werden (z.B.: _root.ip) oder die loadVariablesNum()-Aktion muss angepasst werden (z.B.: loadVariables ("getIP.php", "_root.myClip");).
3.1.8 Umgang mit Verzögerungen Angenommen, das Script, das Sie aufrufen, muss, um das gewünschte Ergebnis zu liefern, erst zeitaufwändige Operationen durchführen, beispielsweise sehr große Datenmengen verarbeiten, die Anfrage an eine Datenbank weitergeben, einen anderen Server kontaktieren etc. Dann dauert die Ausgabe des Ergebnisses etwas länger, eventuell sogar so lange, dass das Ergebnis in Flash erst ankommt, wenn bereits versucht wurde, es auszugeben. Abbildung 3.4 zeigt, was geschieht, wenn man versucht, kurz nach dem Aufruf von loadVariables() oder loadVariablesNum() das Ergebnis in Flash auszugeben.
Abbildung 3.4: Dieses Bild zeigt, was passiert, wenn nicht auf die Ausgabe des Scripts gewartet, sondern versucht wird, das Ergebnis umgehend auszugeben. Der dicke Balken (rechts im Bild) symbolisiert die Zeitdifferenz zwischen Ausgabe und eigentlicher Ankunft des Ergebnisses (der Daten).
Um dieses Problem zu umgehen, muss vor der Weiterverarbeitung des Ergebnisses zuerst geprüft werden, ob dieses bereits vollständig übertragen wurde. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
44
Kapitel 3
Für diese Überprüfung gibt es zwei Möglichkeiten:
Erste Möglichkeit: onClipEvent(data) Dieses Beispiel befindet sich im Ordner Beispiele\checkLoaded\onClipEvent\ auf der CDROM. · HINWEIS
Bei dieser Möglichkeit ist es nicht möglich, die Daten direkt auf eine Ebene zu laden, sondern nur in eine Filmsequenz.
Abbildung 3.5: Aufbau einer SWF-Datei, in der mit der onClipEvent()-Methode geprüft wird, ob Daten aus einem aufgerufenen Script bereits vollständig geladen wurden. Sobald der Ladevorgang beendet ist, wird eine Aktion ausgeführt.
Der Ablauf ist folgender: 1. Daten werden von Flash in eine Filmsequenz geladen. 2. Mit onClipEvent(data) wird überprüft, ob sie bereits vollständig geladen wurden. 3. Wenn die Daten geladen wurden, wird eine oder mehrere Aktionen ausgeführt. Um zu dem obigen Ergebnis zu gelangen, müssen Sie folgende Schritte ausführen: 1. Erstellen Sie einen neuen Flash-Film. 2. Erstellen Sie eine neue Filmsequenz und ziehen Sie diese aus der Bibliothek auf die Bühne. 3. Geben Sie der Filmsequenz bzw. deren Instanz einen eindeutigen Namen (hier: myClip). 4. Erstellen Sie im ersten Frame eine loadVariables()-Aktion, die Daten aus einer Datei oder einem Script in die gerade erstellte Instanz der Filmsequenz (hier: myClip) lädt.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
· HINWEIS
45
Sollten Sie das Caching verhindern wollen, so passen Sie den loadVariables()-Befehl einfach wie in Kapitel 3.1.2 beschrieben an.
5. Der Inhalt der Datei bzw. die Ausgabe des Scripts ist irrelevant, jedoch müssen die Daten wie in Kapitel 3.1.3 beschrieben formatiert sein. Der Inhalt unserer Datei (onClip Event.php) ist folgender:
"&variable1=wert&"; "&variable2=wert&"; "&variable3=wert&"; "&variable4=wert&"; "&eoD=Geladen!&";
?> ·
HINWEIS
Um das Beispiel zu vereinfachen, wird ein statischer Inhalt anstelle eines dynamischen Inhalts verwendet. Das Beispiel funktioniert selbstverständlich auch mit einem PHP-Script, das Daten aus einer Datenbank oder einer anderen Datenquelle holt.
6. Nun muss bei den Objektaktionen der Filmsequenz noch der Befehl onClipEvent() eingefügt und als Ereignis »Daten« markiert werden. Dieser Parameter bewirkt, dass die Aktionen innerhalb der Klammern der Funktion onClipEvent() ausgeführt werden, sobald Daten aus einem Script oder einer Datei per loadVariables() oder loadVariables Num() vollständig in die Filmsequenz geladen wurden. 7. Um beispielsweise nach dem Ladevorgang den Wert einer geladenen Variable auszugeben, muss die Aktion innerhalb des onClipEvent()-Befehls stehen. In unserem Fall ist dies ein trace()-Befehl, der den Wert der letzten Variable (hier: eoD) unserer geladenen Datei ausgibt. ·
HINWEIS
Sollte der Inhalt der zu ladenden Datei oder die Ausgabe des PHP-Scripts leer sein, so werden die Aktionen innerhalb des onClipEvent(data)Befehls trotzdem ausgeführt! Sie erhalten also keine Auskunft darüber, welche und ob überhaupt Daten geladen wurden, sondern nur, dass der Ladevorgang beendet wurde. Wollen Sie überprüfen, ob die Daten, die Sie erwarten, wirklich geladen wurden, so ist es besser, die zweite Möglichkeit zu verwenden.
Zweite Möglichkeit: Schleife mit if-Abfrage Diese Methode benötigt etwas mehr Code als die im vorherigen Abschnitt beschriebene Methode. Hier wird kein Event-Handler verwendet (onClipEvent(data)), sondern eine Schleife über mehrere Bilder, um den Ladevorgang zu überprüfen. Dieses Beispiel befindet sich im Ordner Beispiele\checkLoaded\frameLoop\ auf der CD-ROM.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
46
Kapitel 3
Abbildung 3.6: Aufbau einer SWF-Datei, in der mit einer if-Abfrage geprüft wird, ob Daten von einem aufgerufenen Script bereits vollständig geladen wurden. Sobald die Daten geladen wurden, wird zu einem bestimmten Frame (hier endLoaded) gesprungen. Dauert der Ladevorgang zu lange, wird der Film angehalten.
Der Ablauf ist folgender: 1. Der Ladevorgang wird gestartet. 2. Mit einer Schleife über mehrere Frames wird überprüft, ob die Daten bereits geladen wurden. 3. Wenn die Daten geladen wurden, wird eine oder mehrere Aktionen ausgeführt. Erstellung der Applikation: 1. Erstellen Sie einen neuen Film.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
47
2. Fügen Sie im fünften Frame ein neues Schlüsselbild ein und nennen Sie dieses checkLoaded. ·
HINWEIS
Es muss nicht der fünfte Frame sein. Aus Gründen der Übersichtlichkeit empfiehlt es sich jedoch, weiter auseinander liegende Frames zu verwenden, da dann die Bildbezeichnungen sichtbar werden. Die Bezeichnung spielt ebenfalls keine Rolle; dies ist jedoch der Punkt, an dem später geprüft wird, ob die Variablen schon geladen wurden. Somit sollte er eine Bezeichnung haben, an der man ihn eindeutig erkennen kann.
3. Wählen Sie einen weiteren Frame auf derselben Ebene aus (in unserem Fall den 14.) und bezeichnen Sie ihn wieder eindeutig. Dies ist der Frame, zu dem nach dem Laden der Variablen gesprungen wird, deshalb wurde er hier auch endLoaded genannt. In Frame 21 sollten Sie noch ein Bild einfügen, damit das Ganze etwas übersichtlicher wird. 4. Nun erstellen Sie in Frame 1 eine loadVariablesNum()-Aktion. Als URL kann ein beliebiges Script gewählt werden, das jedoch folgendes Format haben muss:
"&variable1=wert&"; "&variable2=wert&"; "&variable3=wert&"; "&variable4=wert&"; "&varsLoaded=1&";
?> Die letzte Variable ist die Variable, anhand deren Wert (true) geprüft wird, ob die restlichen Variablen, die davor stehen, schon geladen wurden. In diesem Fall ist das die Variable mit dem Namen varsLoaded – Sie können die Variable nennen wie Sie möchten, allerdings muss dann bei der Überprüfung der Code angepasst werden (siehe unten). Verallgemeinert sieht die Formatierung der Ausgabe dann so aus: ... DATEN DATEN DATEN DATEN DATEN DATEN DATEN DATEN DATEN ... &varsLoaded=1& ·
HINWEIS
Die Variable, an der geprüft wird, ob die Daten bereits geladen wurden, muss am Ende der Datei stehen und nicht am Anfang, da Flash die Datei bzw. die Ausgabe eines Scripts immer aufsteigend lädt. Die Platzierung der Variable am Ende stellt also sicher, dass die Daten davor bereits geladen wurden, wenn diese Variable in Flash ankommt.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
48
Kapitel 3
5. Damit die Schleife, sollten keine Daten geladen werden oder ein Fehler im Script auftreten, nicht endlos abläuft (was sowohl überflüssige Ressourcen benötigt als auch den Benutzer unnötig warten lassen würde), benötigen wir weitere Funktionen. Diese Funktionen sind für die Funktion des Scripts nicht relevant; ich empfehle aber, sie zu benutzen, da so etwaige Fehler im Script einfach erkannt werden können. Direkt unter dem loadVariablesNum()-Befehl setzen wir nun zwei Variablen: startTime = getTimer(); Diese Variable brauchen wir später, um zu sehen, wie viel Zeit seit dem Aufruf des loadVariablesNum()-Befehls vergangen ist. timeOut = 10; Diese Variable legt die Zeit (in Sekunden) fest, nach der die Aktionen für den Timeout ausgeführt werden. Sie können den Timeout beliebig wählen. Denken Sie auch an Modem-User, die evtl. etwas länger brauchen, um die Daten zu laden; allerdings sollten für unsere Datenmenge zehn Sekunden ausreichen. 6. Nun muss noch ein gotoAndPlay()-Befehl eingefügt werden, der den Film zu dem Frame springen lässt, an dem die Überprüfung stattfindet (in unserem Fall: Frame 5 mit der Bezeichnung checkLoaded). 7. In Frame 5/checkLoaded kommt jetzt der Code für die Überprüfung. 8. Fügen Sie eine if-Abfrage ein und wählen Sie als Bedingung varsLoaded == true. Sollten Sie in Ihrer Datei eine andere Variable zum Überprüfen des Ladestatus verwenden, müssen Sie die Bedingung bzw. den Variablennamen entsprechend anpassen. ·
Wenn die letzte Variable in Ihrer Datei so aussieht &endOfData=1& dann muss die Bedingung endOfData == true oder endOfData == 1 oder nur endOfData
BEISPIEL
lauten.
Damit die Variable, mit welcher der Ladevorgang überprüft wird (hier: varsLoaded) beim nächsten Laden auf dieselbe Ebene nicht bereits definiert ist bzw. den Wert true (wahr) enthält und somit der Ladevorgang fälschlicherweise für beendet gehalten wird, müssen Sie den Urzustand vor dem Laden wiederherstellen. Dies geschieht mit dem delete-Befehl (innerhalb der if-Abfrage).
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
49
Eine weitere Möglichkeit wäre, die Variable varsLoaded = false zu setzen. Das Ergebnis ist dasselbe.
· HINWEIS
9. Nun können innerhalb der if-Funktion noch Befehle hinzugefügt werden, die ausgeführt werden sollen, wenn die Daten vollständig geladen wurden. In unserem Fall ist das ein gotoAndPlay() auf den Frame mit dem Namen endLoaded. 10. Um zu erkennen, ob das Script schon länger läuft, als die Timeout-Zeit es erlaubt, brauchen wir eine weitere if-Abfrage: if ((getTimer() - startTime) / 1000 >= timeOut) { trace("Timeout!"); stop(); } Dieses Script errechnet die Zeitdifferenz zwischen dem Aufruf des loadVariablesNum()-Befehls und der momentanen Zeit (also die Laufzeit der Anfrage an das Script oder die Datei) und vergleicht diese mit der in Frame 1 festgelegten Timeout-Zeit. Sollte sie größer sein, so werden die Aktionen innerhalb der if-Aktion ausgeführt. Hüten Sie sich vor einer zu kleinen Timeout-Zeit, wenn Sie nicht genau vorausberechnen können, wie groß die Datenmenge ist oder wie schnell die Server sind – prinzipiell gilt: besser eine zu große Timeout-Zeit als eine zu kleine. Bei wichtigen Daten ist es angebracht, auf einen Timeout vollständig zu verzichten!
·
HINWEIS
Timeout-Zeit von PHP (set_time_limit()) Ebenfalls sollte auf die Timeout-Zeit von PHP-Scripts geachtet werden. Die Ausführung von PHP-Scripts ist auf den meisten Servern festgelegt, sie kann aber mit dem Befehl Exkurs
void set_time_limit (int seconds) beeinflusst werden. Bei einem Aufruf von set_time_limit() wird die Ausführungszeit eines Scripts auf 0 zurückgesetzt. Beispiel: DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
50
Kapitel 3
Exkurs
Wenn Sie das Zeitlimit vollständig deaktivieren wollen, müssen Sie set_ time_limit(0) aufrufen. Nach diesem Aufruf läuft das Script, bis es zu Ende ist (oder z.B. bei einem Programmierfehler unendlich lange, dieser Befehl sollte also immer mit Vorsicht eingesetzt werden!). ·
HINWEIS
Im SAFE MODE hat der Aufruf von set_time_limit() keinen Effekt. Es gibt keinen anderen Weg, um die Ausführungszeit eines Scripts zu verlängern, als entweder den SAFE MODE abzuschalten oder das Zeitlimit in der Konfigurationsdatei von PHP zu verändern. Für mehr Informationen hierzu kontaktieren Sie bitte den Administrator Ihres ISP.
11. Solange beide Bedingungen in Frame 5 nicht erfüllt sind, läuft der Film einfach weiter. Demnach müssen wir in Frame 6 eine Aktion einbinden, die einen Rücksprung verursacht. Auf diese Weise werden die Abfragen so lange wiederholt, bis eine der beiden Bedingungen zutrifft. Dazu fügen wir in Frame 6 einfach einen gotoAndPlay()-Befehl ein, der zu der Abfrage zurückspringt. 12. In Schritt 10 haben wir ein Sprungziel festgelegt (Frame 14/endLoaded), zu dem gesprungen wird, wenn die Daten vollständig geladen wurden. Daher müssen wir in diesem Frame noch eine stop()-Aktion einfügen, damit der Film nicht wieder von vorne beginnt. Hier könnten auch Befehle stehen, die nach dem Laden ausgeführt werden sollen, beispielsweise zusätzlich noch ein trace()-Befehl.
3.2 Variablen von Flash an PHP übergeben In diesem Unterkapitel wird darauf eingegangen, wie Daten aus Flash an ein PHP-Script übergeben werden können. Diesen Weg benötigt man, um beispielsweise vom User eingegebene Daten wie etwa bei einem Bestellvorgang in einem Onlineshop in einer Datenbank zu speichern. Ebenfalls kann man PHP verwenden, um Daten zu validieren (z.B. Kreditkartendaten). Doch nicht nur vom Benutzer eingegebene Daten müssen evtl. an ein PHPScript geschickt werden, sondern auch etwa die Position des Besuchers bei der Navigation durch ein dynamisches Menü.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
51
3.2.1 Schema der Übergabe
Abbildung 3.7: Mit den Befehlen loadVariables(), loadVariablesNum() oder getURL() werden Daten aus Flash an ein Script übergeben. Wenn die Funktion zum Aufrufen des Scripts getURL() sein sollte, so können keine weiteren Daten vom Script mehr empfangen werden.
3.2.2 Funktionen zur Übergabe Folgende Funktionen kann man verwenden, um Daten aus Flash an ein Script zu übergeben. Zwei davon kennen wir schon: void loadVariablesNum (string url, mixed position [, int methode]); Die Beschreibung finden Sie in Kapitel 3.1.2. void loadVariables (string url, mixed position [, int methode]); Die Beschreibung finden Sie in Kapitel 3.1.2. Außerdem gibt es noch folgende Funktion: void getURL (string url [, string fenster [, int methode]]); Parameter:
string url Ein absoluter oder relativer URL zu dem Script. string fenster Bezeichnet den (Frame-)Namen eines bestehenden oder eines neuen Browserfensters.
Beispiel:
Um die Ausgabe z.B. in einem neuen Browserfenster anzuzeigen, würde man folgenden Code verwenden: //~ ActionScript getURL("meinScript.php", "_blank"); int methode
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
52
Kapitel 3
Dieser Parameter verhält sich wie bei loadVariablesNum() in Kapitel 3.1.2 beschrieben. Näheres zu verschiedenen Methoden erfahren Sie in Kapitel 3.2.3. Anmerkung:
Ein mit diesem Befehl aufgerufenes Script bzw. dessen Ausgabe lässt sich innerhalb von Flash nicht laden. Diese Methode ist also nur dann geeignet, wenn man vorhat, die Daten mit dem Script weiterzubearbeiten oder im Browser selbst auszugeben. Beispiel: //~ ActionScript getURL("meinScript.php"); Dieser Code lädt nicht etwa die Ausgabe des Scripts (hier: meinScript.php) in Flash, sondern öffnet dieses Script im selben Browserfenster. Die HTMLSeite, die das SWF enthält, von dem dieser Ausruf ausgeht, wird also durch das Script ersetzt.
3.2.3 Verschiedene Übergabearten/Methoden LoadVariables(), loadVariablesNum() und getURL() haben als optionales drittes Argument eine Methode. Da Flash sich HTTP-konform (HTTP = Hypertext Transfer Protocol) verhält, muss die Methode vom Protokoll unterstützt werden. Es gibt viele verschiedene Methoden; die zwei gebräuchlichsten heißen GET und POST. Im Folgenden werden bei beiden Methoden Vor- und Nachteile aufgezeigt. Es ist keine eindeutige Zuordnung möglich, da was einmal ein Nachteil ist, ein anderes Mal ebenso einen Vorteil bedeuten kann. Hier wurde versucht, die verschiedenen Vor- und Nachteile gegeneinander abzuwägen und daraus zu entscheiden, welches Merkmal einer Methode einen Vorteil und welches einen Nachteil darstellt. GET Bei GET werden die Daten mit einem Fragezeichen (?) als Trennzeichen an den URL angehängt und dann weitergesendet. Im Browser des Anwenders ist dies nach dem Absenden des Formulars in der URL-Zeile oder im Cache sichtbar. Vorteile:
Zu versendende Daten können einfach ausgewählt werden.
Nachteile:
Sonderzeichen müssen kodiert werden, d.h. alle nicht alphanumerischen Zeichen bis auf -_. müssen in %, gefolgt von dessen ASCII-Code, umgewandelt werden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
53
Die Länge des Anfrage-Strings ist bei den meisten Server-Systemen beschränkt (1 Kbyte = 1024 Zeichen), daher können bei der Übertragung größerer Datenmengen mit der GET-Methode Daten verloren gehen. Die Daten werden von Proxies und vom Client im Cache gespeichert, was bei sensiblen Daten eine Sicherheitslücke darstellt. ·
Um Daten mit GET zu versenden, sehen die Aufrufe folgendermaßen aus: //~ ActionScript getURL("meinScript.php", "_blank", "GET"); loadVariablesNum("meinScript.php", 0, "GET");
BEISPIEL
loadVariables("meinScript.php", "_root.movieClip", "GET"); POST Bei der POST-Methode werden die Daten nicht an die URL angehängt, sondern in einem eigenen Datenpaket, dem Head-Teil der HTTP-Anfrage an das Script übermittelt.
Vorteile:
Die Daten sind nicht sichtbar und werden weder von Proxies noch vom Client im Cache gespeichert. Um Daten mit der Methode POST zu versenden, müssen sie nicht explizit kodiert werden, dies geschieht automatisch. Es gibt keine Längenbeschränkung, sogar Binärdaten sind möglich (z.B. für Datei-Uploads).
Nachteile:
·
Zu versendende Daten lassen sich nicht so einfach wie bei der GET-Methode wählen. Um Daten mit POST zu versenden, sehen die Aufrufe folgendermaßen aus: //~ ActionScript getURL("meinScript.php", "_blank", "POST"); loadVariablesNum("meinScript.php", 0, "POST");
BEISPIEL
loadVariables("meinScript.php", "_root.movieClip", "POST");
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
54
Kapitel 3
Anwendungsgebiete der Methoden GET sollte bei kleinen Formularen, die keine sensiblen Daten enthalten, und bei Formularen, die eventuell als Lesezeichen abgelegt werden, verwendet werden. Besonders bei großen Datenmengen und/oder sensiblen Daten ist die Methode POST vorzuziehen, da es bei POST weitaus schwieriger ist, sensible Daten auszuspionieren. Zusätzlich zu der POST-Methode sollten diese Daten auch noch verschlüsselt werden z.B. mit SSL (siehe Kapitel 5.2).
3.2.4 Auswahl der zu sendenden Variablen Bei der Verwendung von GET/POST werden alle Variablen, die in Flash definiert wurden und sich auf derselben Ebene bzw. in derselben Filmsequenz befinden, an das Script gesendet. Es ist ohne weiteres nicht möglich, einzelne Variablen am Versenden zu hindern. ·
Sollten im Flashfilm die Variablen Variable Variable Variable Variable
_level0.variable1 = "wert" _level0.variable2 = "wert2" _level0.movieClip.variable3 = "wert" _level2.variable4 = "wert"
vorhanden sein, gibt es folgende vier Möglichkeiten: • Beim Aufruf von: //~ ActionScript _root.getURL("meinScript.php", "_blank", "POST"); würden die Variablen variable1 und variable2 an das Script übergeben. • Beim Aufruf von: //~ ActionScript _root.movieClip.getURL("meinScript.php", "_blank", "POST"); würde die Variable variable3 an das Script übergeben werden. • Bei folgendem Aufruf von _level2 //~ ActionScript _level2.getURL("meinScript.php", "_blank", "POST"); BEISPIEL
würde die Variable variable4 an das Script gesendet werden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
55
• Bei folgendem Aufruf von _level4 //~ ActionScript _level3.getURL("meinScript.php", "_blank", "POST"); würde keine der vier Variablen an das Script übergeben werden. Anmerkung: Um Daten aus einer anderen Ebene als der Ebene 0 (_level0 bzw. _root) zu verschicken, muss diese Ebene erst angelegt werden.
BEISPIEL
Da dies zu unnötigem Datenaufkommen zwischen Flash und Script führt, sollten entweder nicht benötigte Variablen im Voraus gelöscht werden oder der Aufruf aus einer neu erstellten Filmsequenz erfolgen, in die nur die Variablen, die versendet werden sollen, kopiert wurden.
Versenden durch Löschen der Variablen verhindern Eine andere Möglichkeit, um auszuwählen, welche Variablen versendet werden sollen, wäre, die nicht benötigten Variablen zu löschen. Nehmen wir folgendes Szenario: Es sind folgende Variablen definiert: Variable _level0.variable1 = "wert" Variable _level0.variable2 = "wert2" Variable _level0.variable3 = "wert3" Um nun nur die Variablen variable1 und variable3 zu versenden, kann man folgenden Code verwenden: //~ ActionScript delete variable2; _root.getURL("meinScript.php", "_blank", "POST"); In diesem Fall ist die Variable variable2 beim Aufruf des Scripts nicht mehr definiert und wird deshalb auch nicht versendet. Sollten Sie die Variable variable2 nach dem Versenden weiterhin benötigen, so ist von dieser Methode abzuraten.
Versenden durch Kopieren der Variablen verhindern Eine weitere Möglichkeit, um festzulegen, welche Variablen versendet werden und welche nicht, wäre, die zu versendenden Variablen in eine neue (leere) Filmsequenz zu kopieren und den Aufruf zum Senden von dort zu machen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
56
Kapitel 3
·
Es sind folgende Variablen definiert: Variable _level0.variable1 = "wert" Variable _level0.variable2 = "wert2" Variable _level0.variable3 = "wert3" Um nur die Variablen variable2 und variable3 zu versenden, kopieren Sie diese Variablen in eine vorher erstellte (leere) Filmsequenz (hier: emptyClip). //~ ActionScript _root.emptyClip.variable2 = _root.variable2; _root.emptyClip.variable3 = _root.variable3; _root.emptyClip.getURL("meinScript.php", "_blank", "POST");
BEISPIEL
In diesem Fall wären die drei Variablen noch unverändert auf Ebene 0 und die Variablen variable2 und variable3 in der Filmsequenz movieClip. Von dort werden dann nur diese beiden Variablen versendet. Die Variable variable1 ist zwar noch auf Ebene 0, wird aber nicht an das Script übermittelt.
Versenden durch genaue Auswahl der Variablen verhindern Es gibt noch eine weitere Möglichkeit, die zu sendenden Variablen auszuwählen, jedoch basiert diese auf der GET-Methode und sollte somit auch nur angewendet werden, wenn die Kriterien zum Einsatz der GET-Methode (siehe Kapitel 3.2.3) zutreffen. Man kann Variablen auch selbst an den URL anhängen, indem man beim Parameter url bei einer Funktion (getURL(), loadVariables() oder loadVariablesNum()) anstelle von einem String einen Ausdruck angibt. Ein Fragezeichen (?) leitet die Variablen dann ein (trennt sie von dem URL). Weitere Variablen werden mit dem &-Zeichen voneinander abgetrennt. ·
Das folgende Beispiel öffnet das Script meinScript.php in einem neuen Browserfenster und übergibt die Variablen var1 und var2. //~ ActionScript var1 = "Hallo"; var2 = "Welt"; var3 = "Ich werde nicht angehängt, da ich unnötig bin"; varString = "&jetzt=mehrere&verknuepfte=variablen"; getURL("meinScript.php?var1="+var1+"&var2="+var2+varString, "_blank");
BEISPIEL
Der ersten Variable muss ein Fragezeichen (?) vorangestellt werden, damit der Browser erkennt, dass der URL aufgehört hat und eine Variable folgt. Alle weiteren Variablen müssen durch ein &-Zeichen getrennt werden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
57
So werden in diesem Beispiel nur var1 und var2 versendet, var3 ist zwar im SWF definiert, wird aber nicht weitergegeben. varString enthält mehrere Variablen, sie sind bereits im richtigen Format innerhalb des Strings gespeichert. Das Script (hier: meinScript.php) enthält nach oben stehendem Aufruf die Variablen $var1 $var2 $hier $variablen mit den jeweiligen Werten. ·
HINWEIS
Bei dieser Methode gelten alle Beschränkungen, die auch der GET-Methode zu eigen sind. Daher müssen Werte von Variablen, die nicht-alphanumerische Zeichen (ausgenommen -._ ) enthalten, kodiert werden (siehe Kapitel 3.1.3).
3.2.5 Arrays Bei dem Aufruf eines Scripts aus Flash per POST oder GET werden Arrays als kommaseparierte Liste übergeben. Man erhält demnach in PHP einen String mit dem gleichen Namen des Arrays in Flash. Ein Array, das in Flash so aussieht: //~ ActionScript meinArray meinArray[0] meinArray[1] meinArray[2]
= = = =
new Array(); "wert"; "wert"; "wert";
getURL("meinScript.php", "_blank", "POST"); wird an ein PHP-Script so übergeben: $meinArray = wert,wert,wert Die Variable $meinArray enthält also in PHP den Wert wert,wert,wert. ·
Sollten im Array Stellen nicht definiert sein, also quasi so: //~ ActionScript meinArray = new Array(); //~ hier "fehlt" ein Element meinArray[1] = "wert"; meinArray[2] = "wert"; //~ hier "fehlen" zwei Elemente meinArray[5] = "wert";
HINWEIS
getURL("meinScript.php", "_blank", "POST"); DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
58
Kapitel 3
dann wird für jeden fehlenden Wert ein Komma gesetzt. Die Variable meinArray würde in PHP bei oberem Beispiel also so aussehen: HINWEIS
$meinArray = ,wert,wert,,,wert
Die Variable $meinArray enthält in PHP also den Wert ,wert,wert,,,wert. Das Komma am Beginn wird gesetzt, weil bei einem Array die Zählung bei null (0) beginnt. Somit interpretiert Flash dies auch als fehlendes Element. Leere Elemente werden also auch übermittelt. Das ist deshalb wichtig, damit die Indizes wieder richtig rekonstruiert werden können. Sollte man also in PHP die kommaseparierte Liste wieder in ein Array umwandeln wollen und benutzt man dazu den Befehl split(), dann erhält man zwar ein Array mit den richtigen Werten an der richtigen Stelle, jedoch sind die »Lücken« mit leeren Werten aufgefüllt. Will man dies umgehen, so darf man den String nicht mit split() trennen, sondern muss die Funktion preg_split() mit dem Flag PREG_SPLIT_NO_EMPTY (siehe unten) verwenden. Allerdings behalten die Elemente bei dieser Funktion nicht ihre angestammten Stellen. Die Struktur des Arrays bleibt also nicht erhalten, da Flash die Elementschlüssel (keys) nicht mit übergibt. Schlüssel eines Arrays/Key: Wenn array[x] = 0, dann ist x der Schlüssel (engl.: »key«).
Die Funktion preg_split() array preg_split (string pattern, string subject [, int limit [, int flags]]) Tutorial
Mit preg_split() lässt sich ein String anhand eines regulären Ausdrucks trennen. Es wird ein Array zurückgegeben. string pattern Dieser Parameter ist der reguläre Ausdruck, mit dem der String in Elemente zerlegt werden soll. Hilfe zu regulären Ausdrücken finden Sie z.B. unter www.koehntopp.de/php/regexp.html (vielen Dank an die Macher des PHPFAQs). string subject Dieser Parameter ist der String, der zerlegt werden soll. int limit Dieser Parameter gibt an, in wie viele Elemente der String maximal zerlegt werden soll. Der Defaultwert ist kein Limit. Wollen Sie weitere Flags angeben, die maximale Anzahl der Elemente aber nicht beschränken, so tragen Sie hier –1 ein.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
Tutorial
59
int flags Mit Hilfe von so genannten Flags (engl. flag = Markierung, Flagge) können Sie das Verhalten der Funktion preg_split() beeinflussen. Es gibt zwei Flags, einmal: PREG_SPLIT_NO_EMPTY Dieses Flag sorgt dafür, dass von preg_split() keine leeren Elemente zurückgegeben werden. und: PREG_SPLIT_DELIM_CAPTURE Wenn dieses Flag aktiviert ist, dann werden die in Klammern eingeschlossenen Elemente im regulären Ausdruck aufgezeichnet und ebenfalls wiedergegeben. · HINWEIS
Wenn Sie beide Flags anwenden möchten, so trennen Sie diese mit einem | (senkrechter Strich/pipe) voneinander.
Der Code dazu ist folgender:
Assoziative Arrays Assoziatives Array – Dies bedeutet, dass im Index nicht nur Zahlen stehen, sprich der Schlüssel ist nicht-numerisch. ·
BEISPIEL
»normales« Array:
assoziatives Array:
Farben1 0 = Blau 1 = Rot 2 = Weiß
Farben2 dunkel = Blau mittel = Rot hell = Weiß
Farben1[0] und Farben2["dunkel"] würden jeweils den Wert »Blau« liefern. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
60
Kapitel 3
Bei der Übergabe von Arrays aus Flash an PHP per POST oder GET ist zu beachten, dass Werte von Arrays nur dann übergeben werden, wenn der Schlüssel eine Zahl ist (Bug?!). Angenommen, innerhalb von Flash wurde mit folgendem Code //~ ActionScript meinArray = new Array(); meinArray[0] = "1"; meinArray[1] = "2"; meinArray["key"] = "Wird nicht versendet"; meinArray[2] = "3"; ein Array gesetzt, dann ist der Wert, der im PHP-Script ankommt: $meinArray = 1,2,3 In Flash hat das Array vier Elemente; wenn es in PHP ankommt, hat es nur noch drei: Das Element mit dem Schlüssel key wurde nicht mit übergeben. Man muss also darauf achten, dass beim direkten Senden eines Arrays keine Werte mit einem String als Schlüssel vorhanden sind.
Mehrdimensionale Arrays Mehrdimensionales Array – Man spricht von einem mehrdimensionalen Array, wenn die Werte eines Arrays wiederum Arrays sind. Wenn man Arrays mit mehreren Dimensionen hat und diese an ein Script weitergibt, so werden alle weiteren Dimensionen der ersten angehängt. Angenommen, in Flash ist ein Array so definiert: //~ ActionScript meinArray = new Array(); meinArray[0] = "1"; meinArray[1] = "2"; meinArray[2] = "3"; meinArray[3] = new Array(); meinArray[3][0] = "4"; meinArray[3][1] = "5"; meinArray[3][2] = new Array(); meinArray[3][2][0] = "6"; Dieses Array hat drei Dimensionen. Die erste hat drei Werte (1, 2 und 3), die zweite hat zwei Werte (4 und 5) und die dritte hat einen Wert (6). Dieses Array würde dem PHP-Script von Flash so übergeben werden: $meinArray = 1,2,3,4,5,6 DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
61
Sie sehen also, dass alle weiteren Dimensionen eines Arrays an die erste angehängt und dann in eine kommaseparierte Liste konvertiert wurden. Die Dimensionen gehen also verloren. ·
Wie im vorherigen Abschnitt angesprochen, werden Werte mit nicht-numerischen Schlüsseln nicht übergeben. Dasselbe gilt auch, wenn eine Dimension einen String als Schlüssel hat, sprich ein Array, das so definiert ist: //~ ActionScript
HINWEIS
meinArray = new Array(); meinArray[0] = "1"; meinArray[1] = "2"; meinArray[2] = "3"; meinArray["key"] = new Array(); meinArray["key"][0] = "4"; meinArray["key"][1] = "5"; meinArray["key"][2] = new Array(); meinArray["key"][2][0] = "6";
Bei diesem Array hat die zweite Dimension den Schlüssel key. Das Array kommt im PHP-Script so an: $meinArray = 1,2,3 Sie sehen, dass die dritte Dimension, obwohl sie einen numerischen Wert als Schlüssel hat, nicht übergeben wird. Dies liegt daran, dass das zweite Array schon nicht mehr übergeben wird.
Arrays korrekt an PHP übergeben Dieses Beispiel befindet sich im Ordner Beispiele\arrayStuff\coolArrayQuery\ auf der CDROM. Im vorangegangenen Abschnitt wurde auf Probleme eingegangen, die bei der direkten Übergabe von Arrays aus Flash an PHP auftreten Ich möchte hier noch einmal näher erläutern, warum wir die folgende Funktion benötigen, um ein zufrieden stellendes Ergebnis zu bekommen. Angenommen, man hat in Flash ein Array, das normalerweise als kommaseparierte Liste übergeben wird. Diese Übergabe kann fehlschlagen, wenn innerhalb des Arrays Daten auch Kommata enthalten. Beim splitten anhand den Kommata wird dann nicht unterschieden zwischen Kommata, welche einzelne Elemente trennen und Kommata innerhalb von Daten. Dies würde dazu führen, dass Elemente und Daten sich vermischen und das im Endeffekt erhaltene Array somit unbrauchbar ist.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
62
Kapitel 3
Weiterhin übergibt Flash keine assoziativen Arrays, also keine Arrays mit nicht-numerischen Schlüsseln, sprich es würden in einem solchen Fall einfach Elemente fehlen. meinArray = new Array(); meinArray[0] = "1"; meinArray[1] = "2"; meinArray["key"] = "3"; meinArray["key2"] = new Array(); meinArray["key2"][0] = "4"; meinArray["key2"][3] = "5"; meinArray["key2"]["key3"] = new Array(); meinArray["key2"]["key3"][0] = "6"; Array.prototype.printArray = function (myArrayName) { var tempString = this.__pA(myArrayName); delete __tmp__; return tempString; } Array.prototype.__pA = function (arrayName) { for (var i in this) { if (typeof(this[i]) == "object") { this[i].__pA(arrayName+"["+i+"]",destString); } else { if (typeof(this[i]) != "function") { __tmp__ += arrayName+"["+i+"]="+this[i]+"&"; } //~ end if } //~ end if else } //~ end for return __tmp__; } //~ end function arrayString = meinArray.printArray("zahlen"); delete meinArray; //~ altes Array entfernen getURL ("meinScript.php","_self", "POST");
Abbildung 3.8: Der Prototyp printArray wandelt ein in Flash erstelltes Array in einen String um, der von PHP korrekt interpretiert wird.
Um diese beiden Hürden zu überwinden, muss man einen Parser verwenden, der ein Array in Flash in die Standardschreibweise (arrayName[key]=value) umschreibt. Diesen String übergibt man dann an das PHP-Script und wandelt dort die Daten mit der Funktion parse_str() wieder in das Array um. Dies wird im Folgenden beschrieben. Nun könnte man sagen, es sei einfacher, die Variablen in der Form, wie PHP sie benötigt, direkt zu erstellen. Dies funktioniert jedoch nur mit einem Parser, da Flash keine Variablen mit eckigen Klammern zulässt, die innerhalb von Flash deklariert werden (Bug?!). Es ist also nicht möglich, in Flash beispielsweise folgende Variablen (nicht als Array) zu deklarieren: DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
63
//~ ActionScript meineVariable[1] = wert1 meineVariable[2] = wert2 meineVariable[key] = wert3 Wir müssen also eine Funktion schreiben, die uns aus einem Array einen String in dem Format zurückgibt, wie wir es benötigen (vgl. Abbildung 3.8). Der Wert der Variable arrayString in Abbildung 3.8 wäre dann: zahlen[key2][key3][0]=6&zahlen[key2][3]=5&zahlen[key2][0]=4&zahlen[key]= 3&zahlen[1]=2&zahlen[0]=1& Dieses Format wird von PHP korrekt interpretiert, und die angegebenen Arrays sind in PHP nachher auch als solche ansprechbar. Wenn das PHP-Script mit diesen Parametern aufgerufen wurde, dann kann man innerhalb von PHP direkt auf die Variablen zugreifen, indem man sie aus dem in Flash erstellten String herausparst. Dies geschieht mit Hilfe der Funktion parse_str().
Die Funktion parse_str() void parse_str (string str [, array arr]) Die Funktion parse_str() erstellt aus einem String die entsprechenden Variablen. Tutorial
string str Dieser Parameter ist der String, aus dem die Variablen extrahiert werden sollen. array arr] Dieser Parameter ist optional. Sie können ein Array angeben, in das die Variablen geschrieben werden. Lässt man den zweiten Parameter weg, so sind die Variablen direkt ansprechbar. Beispiel: Angenommen, wir haben einen String $string = "&variable=wert&testArray[0]=wert"; und parsen diesen mit der Funktion parse_str() folgendermaßen: parse_str($string); dann lässt sich nach dem Parsen mit $variable; $testArray; auf die Daten zugreifen. Geben wir ein zweites Argument an, etwa so: parse_str($string, $newArray);
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
64
Kapitel 3
ließe sich nachher auf die Variablen so zugreifen:
Tutorial
$newArray["variable"]; $newArray["testArray"][0]; ·
HINWEIS
Wenn Sie nicht genau wissen, wie die Variablen heißen werden, die in dem String enthalten sind, dann ist es sinnvoll, einen zweiten Parameter anzugeben, da eventuell bereits verwendete Variablen mit gleichem Namen überschrieben werden. Geben Sie hingegen ein Array an, in das die Variablen geschrieben werden, kann dies nicht passieren (sofern das als Argument angegebene Array ebenfalls noch nicht deklariert wurde).
Um nun also unseren String, den wir aus Flash bekommen haben, zu parsen und das Produkt von zahlen[1] und zahlen["key"] zu errechnen, benutzen wir folgenden PHP-Code: Dieser Code multipliziert den Wert des ersten Elements des Arrays $zahlen mit dem Wert des Elements mit dem Schlüssel key und gibt das Ergebnis aus. Auf dem Bildschirm bzw. im Browser würde dann Errechnete Zahl: 6 ausgegeben werden. ·
HINWEIS
·
Wenn Variablennamen Leerzeichen enthalten, also z.B. so: &meine+Variable= wert (das +-Zeichen kodiert hier das Leerzeichen), dann werden diese durch Unterstriche ersetzt, die Variable hieße in diesem Beispiel also nachher meine_Variable. Sie können den String selbstverständlich auch direkt an den URL anhängen – quasi so: //~ ActionScript getURL("meinScript.php?"+arrayString, "_self"); würde einen Aufruf ergeben, der so aussähe:
BEISPIEL
meinScript.php?array[0]=wert1&array[1]=wert2&array[key]=wert3
Dadurch können Sie auf die Variablen bzw. auf das Array $zahlen in PHP direkt zugreifen. Jedoch schränkt dies das Anwendungsgebiet dieser Möglichkeit der Übergabe von Arrays wieder ein, da die GET-Methode verwendet wird (siehe Kapitel 3.2.3).
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
65
Sinnvoller und eleganter ist es daher, die parse_str()-Methode von PHP zu verwenden, um aus dem String wieder das entsprechende Array zu formen.
3.2.6 Verarbeitung übergebener Daten in PHP Nachdem Variablen aus Flash an PHP übergeben wurden, kann man auf diese zugreifen. Wie das funktioniert, wird in den folgenden Abschnitten erklärt.
Ansprechen von Variablen Auf übergebene Daten lässt sich in PHP sehr einfach zugreifen. Es ist nicht nötig, den Anfragestring in seine Bestandteile zu zerlegen, wie z.B. in Perl. PHP erledigt das von selbst für uns. Wenn man ein PHP-Script folgendermaßen aufruft meinScript.php?variable=wert so kann man innerhalb von PHP auf die übergebene Variable mit $variable zugreifen (Variablen haben in PHP immer ein vorangestelltes $-Zeichen). Dasselbe gilt für Arrays (siehe auch Kapitel 3.2.5). Bei dem Aufruf meinScript.php?array[0]=wert kann man auf das gesamte Array mit der Variable $array und auf einzelne Elemente (hier Element 1) mit $array[0] zugreifen. Das Anhängen an den URL ist gleichbedeutend mit der GET-Methode (siehe Kapitel 3.2.3). Auf Variablen, die per POST übergeben werden, wird genauso zugegriffen. · HINWEIS
·
Anders als in Flash sind Variablennamen in PHP case-sensitive. Das heißt, in PHP wird bei der Benennung von Variablen zwischen Groß- und Kleinschreibung unterschieden.
BEISPIEL
deklarieren drei unterschiedliche Variablen. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
66
Kapitel 3
$HTTP_POST_VARS und $HTTP_GET_VARS Es kann es sein, dass man nicht genau voraussagen kann, wie viele Variablen an ein PHPScript übergeben werden und wie deren Namen lauten. In diesem Fall kann man nicht direkt auf die Variablen zugreifen, daher muss man einen kleinen Umweg gehen. Dazu gibt es zwei durch PHP vordefinierte Variablen. Das ist einmal für mit der Methode POST übergebene Variablen das Array $HTTP_POST_VARS und für Variablen, die mit der GET-Methode übergeben wurden, das Array $HTTP_GET_VARS In diesen Arrays befinden sich die per GET bzw. per POST übergebenen Variablen. (Ab PHP Version 4.1.0 sind die Namen der Arrays $_POST bzw. $_GET. In PHP 4.1.x existieren die »alten« Variablen noch, sie werden aber in späteren Versionen abgeschafft werden, es ist also sinnvoll, gleich die neuen Variablen zu verwenden, wenn man weiß, dass man eine Applikation für PHP > 4.1 programmiert.) Beide dieser Arrays lassen sich wie normale Arrays verwenden. Der Schlüssel ist der Variablenname und der Wert ist der Variablenwert. Wenn man nun ein PHP-Script folgendermaßen aufruft: meinScript.php?variable1=wert&variable2=wert&array[0]=wert Dieser Aufruf eines Scripts entspricht dem Senden von Variablen mit der GET-Methode. Um die eben übergebenen Variablen auszugeben, muss der Inhalt des Scripts meinScript.php folgender sein: Die Funktion print_r() gibt das Array auf dem Bildschirm aus. Wenn man den Quelltext der Ausgabe betrachtet, sieht man sogar die genaue Struktur der Arrays. Im Browser wird dann Folgendes angezeigt: Array ( [variable1] => wert [variable2] => wert [array] => Array ( [0] => wert ) )
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
67
Diese Werte befinden sich im Array $HTTP_GET_VARS. Das Array $HTTP_POST_VARS ist in diesem Fall leer. Wenn man nun beispielsweise den Wert der Variable variable1 und den Wert des ersten Elements des Arrays array ausgeben möchte, müsste man das mit folgendem Code machen: Dieser Code gibt auf dem Bildschirm bzw. im Browser wert wert aus. Des Weiteren kann es sein, dass man abgesehen von Anzahl und Namen der übergebenen Variablen auch die Methode nicht kennt oder eventuell beide Methoden benutzt. Für diesen Fall gibt es die Funktion array_merge().
Die Funktion array_merge() array array_merge (array array1, array array2 [, array ...])
Tutorial
Die array_merge()-Funktion fügt beliebig viele Arrays zu einem einzigen zusammen und gibt dieses zurück. Beispiel:
·
HINWEIS
Nach PHP Version 4.1.0 sind im Array $_REQUEST alle GET-, POST- und COOKIE-Variablen enthalten. Es ist also nicht mehr nötig, diese mit array_ merge() zusammenzuführen. Das Zusammenführen von diesen kann beispielsweise sinnvoll sein, wenn man sowohl per GET als auch per POST Daten übergibt, auf diese aber in einem einzigen Schritt zugreifen bzw. das zusammengeführte Array in einem Schritt durchlaufen möchte. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
68
Kapitel 3
PHP-Version < 4.1.0 Wenn dieser Aufruf innerhalb einer Funktion oder Klasse geschieht, müssen Sie vorher die Arrays $HTTP_POST_VARS und $HTTP_GET_VARS importieren. ·
PHP-Version < 4.1.0
BEISPIEL
?>
Dies sind zwei Methoden, um auf das Array $HTTP_POST_VARS global zuzugreifen. Die erste Methode unterscheidet sich leicht von der zweiten. Bei der ersten Methode wird das Array $HTTP_POST_VARS als global deklariert, somit kann man direkt innerhalb der Funktion darauf zugreifen. Bei der zweiten Methode wird einem neuen Array (hier: $getArray) der Inhalt des Arrays $HTTP_GET_VARS zugeordnet. Zugegriffen wird hier auf das Array nicht dadurch, dass es global deklariert wird, sondern durch ein global gültiges von PHP definiertes Array ($GLOBALS), das das Array $HTTP_GET_VARS enthält. · HINWEIS
Der gängigere Weg ist der erste, jedoch gibt es weder Vor- noch Nachteile – bis auf den geringfügigen Umstand, dass bei der zweiten Möglichkeit minimal mehr geschrieben werden muss.
Ab PHP Version 4.1.0 existieren (wie oben bereits gesagt) die Arrays $_GET, $_POST, $_COOKIE und $_REQUEST anstelle der »alten« $HTTP_*_VARS. Es ist nicht nötig, $_REQUEST in eine Funktion oder Klasse zu importieren. Der Gültigkeitsbereich dieses Arrays ist global.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
69
PHP-Version > = 4.1.0 Die Arrays $_GET, $_POST und $_COOKIE sind ebenfalls bereits global. ·
PHP-Version >= 4.1.0
HINWEIS
?>
In dem Code oben haben Sie globalen Zugriff auf die Arrays ohne vorherigen Import.
3.2.7 Beispiel: Übergabe und Manipulation eines Strings Um die Funktionsweise einer Übergabe zu verdeutlichen, ist im Folgenden ein sehr einfaches Beispiel erklärt. Es wäre in diesem Falle nicht unbedingt nötig, PHP einzusetzen, um zum gewünschten Ergebnis zu kommen, aber um die Arbeitsweise zu verdeutlichen, ist es gut geeignet. Dieses Beispiel befindet sich im Ordner Beispiele\reverseName\ auf der CDROM.
Abbildung 3.9: Dieser Flash-Film erlaubt es dem Benutzer, seinen Namen einzugeben, der dann URL-kodiert und an ein PHP-Script weitergegeben wird.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
70
Kapitel 3
Der Ablauf ist folgender: 1. Der Besucher wird zur Eingabe seines Namens aufgefordert. 2. Der Name wird URL-kodiert und an ein PHP-Script weitergeleitet. 3. In PHP wird der Name umgedreht und wieder an den Browser ausgegeben. Erstellung der Applikation: 1. Erstellen Sie einen neuen Film. 2. Legen Sie im ersten Frame ein leeres dynamisches Textfeld mit dem Namen name an. 3. Erstellen Sie einen Button, ziehen Sie ihn auf den Arbeitsbereich und geben Sie ihm folgende Aktionen: on (release) { getURL("reverseName.php?name="+escape(name)); } Bei einem Klick auf diesen Button wird der Inhalt des Textfeldes URL-kodiert mit dem Variablennamen name an das PHP-Script reverseName.php angehängt. 4. Der Inhalt des PHP-Scripts reverseName.php ist folgender: Die Funktion strrev() kehrt den übergebenen String um. Dann wird er wieder ausgegeben.
Die Funktion strrev() string strrev (string string) Diese Funktion gibt den String string umgekehrt zurück. Tutorial
Beispiel: gibt aus: Hallo
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
71
3.3 Beispiel: Ein Feedback-Formular Dieses Beispiel befindet sich im Ordner Applikationen\swfFeedback\ auf der CD-ROM. Inhalt des SWF:
Abbildung 3.10: Dieser Flash-Film ist ein komplettes Feedback-Formular in Flash, das den Status der E-Mail bzw. auftretende Fehler an Flash zurückgibt.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
72
Kapitel 3
Der Ablauf ist folgender: 1. Die Daten werden vom Besucher eingegeben und an das PHP-Script übergeben. 2. Dort werden die Daten auf Gültigkeit überprüft. (Ist die E-Mail-Adresse gültig? Sind alle Felder ausgefüllt?) 3. Der Ergebniscode wird an Flash zurückgegeben und dort ausgewertet. 4. Bei einem Fehler erscheint die Fehlermeldung, und der User wird zur Korrektur aufgefordert. Ansonsten erscheint eine Meldung, die besagt, dass die E-Mail erfolgreich verschickt wurde. Aufbau der Applikation: 1. Erstellen Sie einen neuen Film. 2. Erweitern Sie die Länge der vorhandenen Ebene auf drei Frames. 3. Erstellen Sie eine weitere Ebene mit drei Frames. 4. Auf einer der Ebenen fügen Sie drei Schlüsselbilder ein (hier auf der Ebene 2). Im ersten Schlüsselbild sind die Daten, die zum Versenden gebraucht werden (in unserem Fall wären das die Felder: email, subject und message). Sollten Sie Eingabefelder mit anderen Variablennamen oder zusätzliche Eingabefelder benötigen, so müssen Sie das PHPScript später entsprechend anpassen. Fügen Sie nun diese drei Texteingabefelder mit den entsprechenden Namen im ersten Schlüsselbild ein. Außerdem wird eine stop()-Aktion benötigt, damit der Film nicht einfach weiterläuft, sondern auf die Eingabe des Besuchers wartet. 5. Im zweiten Schlüsselbild fügen Sie einen Text ein, der während des Übertragungsvorgangs eingeblendet werden soll. In unserem Fall steht da »Bitte warten«; der Text ist jedoch nicht relevant, es kann genauso eine Ladeanimation oder ein anderer Text sein. Ebenfalls in diesem Schlüsselbild sollte auch das Array deklariert werden, das die verschiedenen Statustexte enthält. In unserem Fall ist das messageArray. Es wäre auch denkbar, die Statusmeldungen vom PHP-Script übergeben zu lassen. Dies erfordert jedoch zusätzliche Zeit, zusätzliches Datenvolumen und ist nicht zwingend nötig, da die Meldungen immer dieselben bleiben. Aus diesen Gründen wurde hier davon abgesehen und das Array gleich in Flash deklariert. 6. Im dritten Schlüsselbild müssen Sie ein dynamisches Textfeld einfügen, damit das Ergebnis der Übermittlung ausgegeben werden kann. In unserem Fall lautet die Variable des dynamischen Textfeldes statusMessage. Fügen Sie auch einen Button ein, mit dem zum ersten Frame zurückgesprungen werden kann, falls es einen Fehler bei der Übertragung gab, oder benötigte Daten nicht oder falsch angegeben wurden und vom Besucher korrigiert werden müssen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Dynamische Inhalte
73
7. Nun benötigen wir noch den ausführenden Teil des Flash-Films. Fügen Sie hierzu eine beliebige (leere) Filmsequenz auf die Ebene ein, die keine Schlüsselbilder enthält. Nennen Sie diese Filmsequenz emptyClip. Weisen Sie nun der Filmsequenz eine onClipEvent(data)-Aktion zu, die – nachdem die Daten bzw. das Ergebnis geladen wurde – die Variable statusMessage mit dem Arrayelement gleichsetzt, das zur jeweiligen result-Variable (von PHP zurückgegeben) gehört. Beispiel: Wenn die E-MailAdresse falsch eingegeben wurde und ungültig ist, dann gibt das PHP-Script &result=3& aus. Das dritte Element des Arrays messageArray enthält die entsprechende Statusmeldung dazu. Der von Flash ausgeführte Code wäre dann: _root.statusMessage = _root.messageArray[3]; Da dies jedoch dynamisch geschehen muss, wird anstelle der 3 die Variable eingesetzt, die das PHP-Script zurückgibt. Der Wert dieser Variable enthält ja den Statuscode. Also so: _root.statusMessage = _root.messageArray[result]; Danach sollte zum nächsten Frame auf der Hauptzeitleiste gesprungen werden. 8. Um die Daten der Textfelder an das PHP-Script zu übertragen und die Daten zu empfangen, muss nun noch im ersten Frame (auf der Ebene mit den Schlüsselbildern) ein Button erstellt werden, der per loadVariables den URL des PHP-Scripts aufruft, die Daten per POST an jenes überträgt und dann zum nächsten Frame springt. Geben Sie als Ziel für die Daten die Filmsequenz an, die Sie auf der Ebene ohne Schlüsselbilder erstellt haben. 9. Nun könnten Sie dem dritten Schlüsselbild noch ein Script zuordnen, das die (betroffenen) Textfelder leert, damit niemand Ihren Posteingang mit unnötigen, eventuell leeren E-Mails füllt (würden Sie diese nicht leeren, müsste die entsprechende Person ja nur auf die Senden-Taste klicken, um E-Mails zu verschicken). Anhand des Wertes der Variable result, die von PHP zurückgegeben wird, können Sie erkennen, wo der Fehler lag. (Die Variable result befindet sich nach dem Ladevorgang innerhalb der leeren Filmsequenz. Wenn Sie die leere Filmsequenz auf der ersten Ebene mit einem anderen Namen benannt haben als im Beispiel, so müssen Sie das Script entsprechend anpassen.) In unserem Fall werden die Textfelder nur geleert, wenn die E-Mail korrekt versendet wurde, andernfalls bleiben die eingegebenen Daten in den Textfeldern erhalten.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
74
Kapitel 3
E-Mail: Betreff: Hallo Mitteilung: schöne Grüße!
Senden
Bitte alle benötigten Felder ausfüllen
Zurück
E-Mail: [email protected] Betreff: Hallo Mitteilung: schöne Grüße!
Senden
Alles okay, eMail versendet
Zurück
Abbildung 3.11: Ablauf einer Feedback-Meldung mit dem beschriebenen Formular. Hier gibt der Besucher zuerst keine E-Mail-Adresse ein, er wird aufgefordert, alle benötigten Felder auszufüllen. Nachdem er dies getan hat, wird die Feedback-Meldung versendet.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
KAPITEL 4
PHP, MYSQL UND FLASH
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
76
Kapitel 4
MySQL (www.mysql.com) ist ein relationales Datenbanksystem. Abfragen bzw. manipulieren lässt sich die Datenbank mit der Sprache SQL (Structured Query Language). Da sowohl PHP als auch MySQL frei erhältlich sind, wird diese Kombination von vielen ISPs angeboten. · HINWEIS
Das in diesem Kapitel Gezeigte funktioniert prinzipiell auch mit allen anderen Datenbanksystemen. Eventuell sind kleinere Anpassungen nötig.
PHP bietet ein komfortables Interface zur Kommunikation mit MySQL und ist deshalb eine beliebte Sprache zum Aufbau von kleineren Applikationen mit MySQL, wie Foren und Gästebücher. Zusammen mit Flash ergeben sich noch weitere Einsatzmöglichkeiten wie z.B. OnlineSpiele oder Chats. Mehr Informationen, Beispiele und Tutorials finden Sie unter: www.little-idiot.de/mysql/
4.1 Interaktionsschema
Abbildung 4.1: Ablauf der Interaktion zwischen Flash und der Datenbank über ein serverseitiges Script
Zuerst werden aus Flash an das Script Daten übergeben. Das Script formt die Daten um und gibt diese im korrekten Format (SQL) an die Datenbank weiter. Diese gibt das gewünschte Ergebnis zurück, welches das Script aufbereitet, also in ein für Flash lesbares Format umwandelt und ausgibt. Die Ausgabe wird von Flash aufgefangen und kann dann weiterverwendet werden. Aus dem Interaktionsschema ergibt sich Folgendes: • Flash kann nicht direkt auf eine Datenbank zugreifen, es wird also ein »Übersetzer« benötigt: ein serverseitiges Script, das die entsprechende Datenbank ansprechen kann (in unserem Fall ist das PHP). • Es gibt zwei verschiedene Interaktionsketten, beide laufen nacheinander ab und sind abhängig voneinander. Das Script in der Mitte muss anhand der Daten, die es von der einen Seite bekommt (in unserem Fall ist das Flash), die zweite Interaktion einleiten.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
·
77
Es wäre theoretisch möglich, ein PHP-Script zu erstellen, das ein bereits korrekt formatiertes SQL-Statement aus Flash nur an die Datenbank weiterleitet, das Ergebnis empfängt, dieses dann aufbereitet und an Flash zurückgibt. Dies wäre eine sehr komfortable Methode, da man ohne weiteren PHP-Code direkt an die gewünschten Ergebnisse kommen würde. Von dieser Methode rate ich jedoch dringend ab. Daten aus vertrauensunwürdiger Quelle (sprich: vom Besucher) dürfen niemals ohne Validierung im PHP-Script verwendet werden. Nehmen wir an, der Programmierer des Flash-Filmes ruft den URL eines solchen Scripts mit einem SQL-Statement auf, das Daten aus einer Datenbank liest. Dies ist an sich harmlos, solange die Daten öffentlich sind. Da der URL aber bekannt ist (er wird von Flash ja aufgerufen), könnte eine Drittperson anstelle des vorgesehenen SQL-Statements ohne weiteres auch einen Befehl an das Script schicken, das Daten aus der Datenbank löscht oder im schlimmsten Falle die gesamte Datenbank zurücksetzt.
HINWEIS
Nehmen Sie sich also die Zeit, Ihre Scripts auf einen individuellen Fall anzupassen und überprüfen Sie jede Eingabe, die vom Client kommt. So ersparen Sie sich unnötigen Ärger und lassen weniger Lücken für Hacker offen.
4.2 Die Klasse swiffSQL Mit der Klasse swiffSQL können Sie direkt aus Flash auf eine MySQL-Datenbank zugreifen.
Abbildung 4.2: Das swiffSQL-Logo. Vielen Dank an Marco Stix (www.prografix.at).
Sie legen in Flash einen SQL-String fest und schicken diesen an ein PHP-Script, in das die Klasse eingebunden ist. Zurück erhalten Sie wahlweise Variablen in der Form: &row_name_1=wert1& &row_name_2=wert2& &result_total=2& &result=1& Oder XML-Daten in der Form: DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
78
Kapitel 4
Wobei bei beiden row_name gleich dem bzw. den Spaltennamen in der Tabelle ist. ·
Wenn die Tabelle eine solche Struktur hat: fruits id
fruit
1
Erdbeere
2
Banane
3
Zitrone
wird bei folgendem Query SELECT * FROM fruits folgende Ausgabe geliefert: • Bei Variablen: &id_0=1& &fruit_0=Erdbeere& &id_1=2& &fruit_1=Banane& &id_2=3& &fruit_2=Zitrone& &result_total=3& &result=1& • Bei XML:
BEISPIEL
Diese zwei Ausgabeformen werden von Flash verstanden. Somit kann die Ausgabe ohne Weiterverarbeitung bzw. Umformung direkt von Flash gelesen werden. Wie in der Einleitung bereits beschrieben wurde, wäre es das Einfachste, einfach einen SQL-String aus Flash an ein PHP-Script weiterzugeben, das diesen einfach an die MySQLDatenbank weitergibt, das Ergebnis empfängt und an Flash ausgibt.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
79
Im Normalfall ist dies eine große Sicherheitslücke, da Unbefugte auch Befehle an die MySQL-Datenbank senden können, um diese zu verändern, zu löschen etc. Nun stellt sich die Frage, was hier anders ist als an einem solchen PHP-Script. In der Klasse swiffSQL ist es möglich, den Zugriff zu beschränken, d.h. man kann einzelne MySQL-Befehle sperren oder freigeben. So ist es beispielsweise möglich, den SELECT-Befehl freizugeben, alle anderen Befehle aber nicht. Dies schafft hinreichende Sicherheit in Hinblick auf ungewollte Manipulationen.
4.2.1 Wichtige Hinweise • Die Klasse swiffSQL befindet sich noch in der Beta-Phase. Auf www.flashtool.de/ swiffSQL/ finden Sie jeweils die neueste Version. Momentan sind noch nicht alle MySQL-Funktionen implementiert und es kann nur ein Objekt der Klasse instanziiert werden, da sich die Ausgaben sonst vermischen und überschreiben. Bitte senden Sie Bugs und/oder Anregungen an: [email protected] . • In MySQL Version 4.x werden so genannte Sub-Selects möglich sein. Sollte hierbei ein Sub-Select mit einer anderen Aktion als SELECT möglich sein, so greift die Zugriffsbeschränkung von swiffSQL eventuell nicht mehr korrekt. Momentan befindet sich MySQL 4 noch in der Alpha-Phase.
4.2.2 Funktionsübersicht swiffSQL() Beschreibung: Erstellt ein neues Objekt der Klasse swiffSQL, die eine Datenbankverbindung hält, zu der dann Anfragen gesendet werden können. Definition:
new swiffSQL (string outputType, string database [, string host [, string user [, string password [, int port]]]])
Parameter:
string outputType Mit diesem Argument legt man die Art der Ausgabe fest, die nach einem Query zurückgegeben wird. Mögliche Werte sind VAR für die Ausgabe des Ergebnisses als Variablen oder XML für die Ausgabe in XML. Denken Sie daran, die flash.inc.php-Klasse einzubinden, falls Sie als Ausgabeart VAR wählen. string database Mit diesem Argument wird die Datenbank angegeben, zu der eine Verbindung erstellt wird.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
80
Kapitel 4
string host Der Server, auf dem die Datenbank sich befindet. Optionales Argument. Defaultwert ist localhost. string user Dieses Argument ist der Benutzer der Datenbank. Optionales Argument. Defaultwert ist root. string password Das Passwort zum angegebenen Benutzer. Optionales Argument. Defaultwert ist kein Passwort. int port Der Port, auf dem die Datenbank »lauscht«. Optionales Argument. Defaultwert ist Port 3306. Anwendung:
Dieser Code erzeugt eine neue Verbindung zu der Datenbank database auf localhost. Das Ergebnis oder eventuelle Fehlermeldungen werden als XML-Daten ausgegeben. swiffSQL->setPermissions()
Beschreibung: Mit dieser Funktion lässt sich der Zugriff auf die Datenbank beschränken (oder gewähren). Diese Funktion muss nicht zwingend aufgerufen werden. Standard ist nur lesen (SELECT). Hier sind nur einige Befehle für den Zugriff auf Daten in einer MySQLDatenbank definiert. Sollte ein Befehl eingegeben werden, der momentan nicht definiert ist (z.B. ALTER oder SHOW), wird eine Fehlermeldung ausgegeben. Definition:
void swiffSQL->setPermissions ([bool select [, bool insert [, bool update [, bool delete [, bool truncate [, bool drop]]]]]])
Parameter:
bool select Wenn bei diesem Parameter true (wahr) angegeben wird, ist das Lesen der Datenbank erlaubt. Optionaler Parameter. Standard ist true.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
81
bool insert Wenn bei diesem Parameter true (wahr) angegeben wird, können Daten in die Datenbank eingefügt werden. Optionaler Parameter. Standard ist false. bool update Wenn bei diesem Parameter true (wahr) angegeben wird, können Daten in der Datenbank verändert werden. Optionaler Parameter. Standard ist false. bool delete Wenn bei diesem Parameter true (wahr) angegeben wird, können Daten in der Datenbank gelöscht werden. Optionaler Parameter. Standard ist false. Es wird nicht empfohlen, diesen Parameter zu ändern. bool truncate Wenn bei diesem Parameter true (wahr) angegeben wird, kann die Tabelle geleert werden. Optionaler Parameter. Standard ist false. Es wird nicht empfohlen, diesen Parameter zu ändern. bool drop Wenn bei diesem Parameter true (wahr) angegeben wird, können Tabellen, Datenbanken etc. gelöscht werden. Optionaler Parameter. Standard ist false. Es wird nicht empfohlen, diesen Parameter zu ändern. Anwendung:
setPermissions(true, true); //~ Ab hier ist auch das Einfügen von Daten erlaubt //~ Hier kommt dann die Anfrage ?> swiffSQL->query()
Beschreibung: Sendet über die erstellte Verbindung eine Anfrage an die Datenbank und gibt das Ergebnis aus. Schlägt fehl und meldet einen Fehler, wenn der Zugriff nicht gestattet ist (siehe Funktion swiffSQL->setPermissions()).
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
82
Kapitel 4
Mögliche Ausgaben: • Bei Ausgabe von Variablen: • Bei SELECT: &row_name1=wert1& &row_name2=wert2& &result_total=2& &result=1& • Bei INSERT: &insert_id=ZAHL& &result=1& Anmerkung: ZAHL ist bei einer Tabelle, in der ein auto_increment-Feld vorhanden ist, eine Zahl größer als 0. In einer Tabelle, in der kein auto_increment-Feld definiert wurde, ist ZAHL gleich 0. • Bei DELETE oder UPDATE: &affected_rows=ZAHL& &result=1& Anmerkung: ZAHL ist die Anzahl der geänderten Zeilen. • Bei allen anderen Befehlen: &result=1& • Bei Fehlern: &error=Fehlermeldung& &result=0& Anmerkung: Bei Fehlern wird das Script beendet. • Bei Ausgabe von XML: • Bei SELECT:
• Bei INSERT: ·
HINWEIS
ZAHL ist bei einer Tabelle, in der ein auto_increment-Feld vorhanden ist, eine Zahl größer als 0. In einer Tabelle, in der kein auto_increment-Feld definiert wurde, ist ZAHL gleich 0.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
83
• Bei DELETE oder UPDATE: Anmerkung: ZAHL ist die Anzahl der geänderten Zeilen. • Bei allen anderen Befehlen: • Bei Fehlern: <error message="Fehlermeldung" /> Anmerkung: Bei Fehlern wird das Script beendet. Definition:
void swiffSQL->query(string sql)
Parameter:
string sql Ein gültiger und korrekt formatierter SQL-String.
Anwendung:
query("SELECT * FROM fruits"); ?> Dieser Code liefert alle Datensätze der Tabelle fruits in der Datenbank database auf dem Server localhost als XML-Daten. swiffSQL->close()
Beschreibung: Schließt die Verbindung zur Datenbank. Die Verbindung wird zwar beim Beenden des Scripts automatisch geschlossen, jedoch werden während der Laufzeit Ressourcen freigegeben, wenn Sie die Verbindung sofort nach erfolgter Anfrage selbst beenden. Definition:
void swiffSQL->close(void)
Parameter:
Keine.
Anwendung:
query("SELECT * FROM fruits"); $swiffSQL->close(); ?> Dieser Code öffnet eine Verbindung zu einer Datenbank, stellt eine Anfrage, gibt das Ergebnis als XML-Daten aus und schließt die Verbindung. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
84
Kapitel 4
4.2.3 Umgang mit der Klasse swiffSQL Prinzipiell lässt sich sagen, dass die Ausgabe von XML-Daten eleganter und auch komfortabler ist. Wenn man XML ausgibt, muss man weder im Voraus die Namen der Felder in der Datenbank wissen, noch muss man eine Ergebnisvariable abfragen. Man muss »nur« das XML-Objekt durchlaufen, und man erkennt, ob und was für Daten geladen wurden. Bei der Ausgabe von XML hat man im Gegensatz zur Ausgabe von Variablen einen Geschwindigkeitsverlust. Sowohl das Laden von XML-Daten als auch das Parsen dauert länger, als dies bei Variablen der Fall ist. Da sich bei verschiedenen Applikationen Unterschiedliches anbietet (bei zeitkritischen Applikationen wie z.B. einem Chat eher Variablen, bei einem Gästebuch etwa XML), möchte ich hier auf beide Möglichkeiten, Daten zu laden, eingehen. Die Datenbankstruktur für die zwei folgenden Beispiele (liegt auf CD-ROM bei: Beispiele\swiffSQL\fruits.sql): fruits id
fruit
color
1
Erdbeere
rot
2
Banane
gelb
3
Zitrone
gelb
4
Melone
grün
4.2.4 Beispiel: Daten laden (Variablen) Dieses Beispiel befindet sich im Ordner Beispiele\swiffSQL\Lessons\fruchtSuche\ auf der CD-ROM. Aufbau des PHP-Scripts: query($sql); $swiffSQL->close(); ?>
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
85
Aufbau des SWF:
Abbildung 4.3: In diesem SWF kann der Besucher eine Farbe eingeben, dann wird in der Datenbank nach einer Frucht mit entsprechender Farbe gesucht. Wenn eine oder mehrere Früchte gefunden werden, werden diese ausgegeben.
Ablauf der Applikation: 1. Im SWF wird vom Besucher eine Farbe eingegeben. 2. Diese Farbe wird in einen SQL-String eingefügt und an ein PHP-Script weitergeleitet.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
86
Kapitel 4
3. Das PHP-Script sendet die Anfrage an die Datenbank, eine Frucht mit der Farbe, die der Besucher zuvor eingegeben hat, zu suchen, und gibt dann das Ergebnis in Flash-kompatiblem Format (hier Variablen) aus. 4. Das SWF lädt das Ergebnis und überprüft, ob Früchte gefunden wurden. Falls ja, werden diese in einem Textfeld angezeigt, falls nicht, wird eine Meldung ausgegeben. ·
In diesem Beispiel wird ein SQL-String im SWF generiert und an das PHP weitergeleitet. Es wäre in diesem Fall sinnvoller, nur die Farbe zu übergeben, da das SWF an keiner sonstigen Stelle mit der Datenbank bzw. dem PHP in Interaktion tritt. Dieses Beispiel ist bewusst einfach gehalten, um den Umgang mit der swiffSQL-Klasse zu zeigen.
HINWEIS
Auf der CD-ROM befinden sich zwei Interfaces (eines für Variablen und eines für XML), die die Flexibilität der swiffSQL-Klasse zeigen. Nachdem Sie dieses Beispiel verstanden haben, sollten Sie unbedingt einen Blick auf diese Interfaces werfen.
Die Interfaces befinden sich im Ordner Beispiele\swiffSQL\Interfaces\ auf der CD-ROM. Aufbau der Applikation: 1. Erstellen Sie einen neuen Flash-Film. 2. Fügen Sie ein Texteingabefeld ein, in das die Farbe eingegeben werden kann, und nennen Sie es farbe. 3. Erstellen Sie ein weiteres dynamisches Textfeld (mehrzeilig mit Zeilenumbruch) mit der Variable message. In diesem Textfeld wird nachher entweder die Meldung ausgegeben, dass keine Früchte mit der gesuchten Farbe gefunden wurden, oder bei Erfolg die gefundenen Früchte. 4. Nun benötigen wir noch eine leere Filmsequenz. In diese werden die Daten bzw. die Ausgabe des PHP-Scripts geladen. Nennen Sie die Filmsequenz emptyClip und weisen Sie ihr folgenden Code zu: onClipEvent (data) { if (result == 1) { //~ Daten korrekt geladen if (result_total == 0) { //~ Keine Früchte gefunden _root.message = "Keine Frucht mit dieser Farbe in der Datenbank!"; } else { //~ Früchte gefunden _root.message = "Diese Früchte haben die gewünschte Farbe:\n"; for (i = 0; i < result_total; i++) { //~ Alle gefundenen Früchte anzeigen
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
87
_root.message += this["fruit_"+i]+"\n"; } //~ end for } //~ end if //~ Geladene Variablen löschen for (var v in this) { delete this[v]; } //~ end for } //~ end if } //~ end onClipEvent Vom PHP-Script werden folgende Daten zurückgegeben: • Bei Erfolg: – Bei keinen gefundenen Früchten: &result=1& &result_total=0& – Bei zwei gefundenen Früchten: &result=1& &fruit_1=Banane& &fruit_2=Zitrone& &result_total=2& • Bei Fehlschlag: &result=0& &error=Fehlermeldung& In diesem Beispiel wird nicht auf Fehlschlag überprüft, sondern nur darauf, ob Früchte gefunden wurden oder nicht. Sobald alle Daten geladen wurden (onclipEvent(data)), wird überprüft, welchen Wert result hat. Wenn der Wert gleich 1 sein sollte (also Erfolg), dann wird überprüft, ob result_total (die Anzahl der gefundenen Früchte) gleich 0 ist. Wenn ja, wird eine Meldung ausgegeben, dass keine Früchte gefunden wurden, wenn nein, dann wird eine andere Meldung im Textfeld message angezeigt und die Früchte angehängt. Da die Früchte sich ja in der Form &fruit_1=name& &fruit_2=name& ... &fruit_n=name& in der Filmsequenz befinden und man die Gesamtzahl weiß (result_total), kann man diese Variablen einfach mit einer Schleife zusammensetzen und auslesen. Nachdem die Früchte angezeigt wurden bzw. die Meldung ausgegeben wurde, müssen die geladenen Variablen wieder gelöscht werden, da es möglich ist, dass der Besucher eine neue Anfrage startet.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
88
Kapitel 4
5. Um eben diese Anfrage starten zu können, wird auf Ebene 0 neben dem Eingabefeld für die Farbe noch eine Schaltfläche benötigt. Erstellen Sie diese und weisen Sie ihr folgenden Code zu: on (release, keyPress "<Enter>") { // ~ Textfeld auf Ebene 0 leeren delete _root.message; // ~ SQL String erstellen sql = "SELECT fruit FROM fruits WHERE color = '"+farbe+"'"; // ~ Dokument laden loadVariables("query.php", "emptyClip", "POST"); } //~ end on Zuerst wird das Ausgabefenster geleert, damit das Ergebnis der letzten Suche nicht eventuell stehen bleibt. Dann wird der SQL-String erstellt. Dieser ist vorformatiert, und die Eingabe des Besuchers wird an der entsprechenden Stelle eingefügt. Dann wird der SQL-String an das PHP-Script übertragen und die Ausgabe in die Filmsequenz emptyClip geladen. Sie können den SQL-String auch nur an den URL anhängen und mit escape() URL-kodieren, es ist jedoch sinnvoller (vor allem, wenn der String länger ist), diesen nicht an den URL anzuhängen, da einerseits Daten verloren gehen können, wenn er zu lang ist, und andererseits eventuell unbefugte Personen auf dumme Ideen gebracht werden. Wenn Sie den SQL-String per POST übermitteln, sollten Sie darauf achten, dass keine anderen Daten unnötigerweise an das PHP-Script gesendet werden, da dies den Vorgang nur unnötig verlangsamen würde (siehe auch Kapitel 3.2.4). 6. Nun wenden wir uns dem PHP-Script zu. Binden Sie zuerst die Klassendatei für die swiffSQL-Klasse ein, damit Sie auf deren Funktionen zugreifen können:
PHP, MySQL und Flash
89
8. Als Nächstes senden wir die Anfrage an die Datenbank: //~ Variable $sql kommt vom swf $swiffSQL->query($sql); Die Variable $sql wurde zuvor aus Flash an das Script gesendet und enthält den SQLString inklusive der gesuchten Farbe. Die Anfrage wird nun an die Datenbank abgesetzt, das Ergebnis empfangen und als Variablen für Flash lesbar wieder ausgegeben. 9. Nachdem die Anfrage an die Datenbank abgesetzt und das Ergebnis empfangen wurde, können wir die Verbindung wieder schließen: $swiffSQL->close(); ?>
4.2.5 Beispiel: Daten laden/einfügen (XML) Dieses Beispiel befindet sich im Ordner swiffSQL\Lessons\enterFruit\ auf der CD-ROM. Der XMLNode-Prototyp insertAction(): XMLNode.prototype.insertAction = function () { if (this.firstChild.nodeName == "insert_id") { //~ Frucht erfolgreich eingefügt //~ Früchte laden getFruits(); } else if(this.firstChild.nodeName == "error") { //~ Frucht nicht erfolgreich eingefügt //~ Fehlermeldung ausgeben message = this.firstChild.attributes.text; } } Der XMLNode-Prototyp showFruits(): XMLNode.prototype.showFruits = function () { if (this.firstChild.nodeName == "result") { var array = this.firstChild.childNodes; for (var k = 0; k < array.length; k++) { message += array[k].attributes.fruit; message += " - "; message += array[k].attributes.color; message += "\n"; }
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
90
Kapitel 4
} else if (this.firstChild.nodeName == "error") { message = this.firstChild.attributes.text; } } Aufbau des SWF:
Abbildung 4.4: In diesem SWF kann der Besucher eine Frucht inkl. Farbe in eine Datenbank eintragen und bekommt danach eine Liste mit allen Früchten zurück.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
91
Aufbau des PHP-Scripts: setPermissions(true, true); //~ Anfrage stellen $swiffSQL->query($sql); //~ Verbindung schließen $swiffSQL->close(); ?> Ablauf der Applikation: 1. Beim Start des SWF wird ein PHP-Script aufgerufen, das alle in der Datenbank befindlichen Früchte als XML-Daten ausgibt. Diese Ausgabe wird geladen, und dann werden alle vorhandenen Früchte inklusive ihrer Farbe in einem Textfeld dargestellt. 2. Der Besucher hat die Möglichkeit, eine eigene Frucht in die Datenbank einzufügen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
92
Kapitel 4
3. Wenn der Benutzer dies möchte, werden die Daten (Frucht und Farbe) an ein PHPScript übergeben, das den Eintrag in die Datenbank vornimmt. Zurückgegeben werden XML-Daten, die den Status enthalten. 4. Nach dem Eintragen wird die Liste mit den Früchten, die sich nun in der Datenbank befinden, erneut vom SWF geladen und im Textfeld dargestellt. · HINWEIS
Wenn Sie ein etwas allgemeineres Beispiel zum Umgang mit swiffSQL und XML-Ausgabe betrachten möchten, können Sie ein Interface (XMLquery) auf der CD-ROM unter Beispiele\swiffSQL\Interfaces\XML\ finden.
Aufbau der Applikation: 1. Erstellen Sie eine neue PHP-Datei (query.php) und binden Sie die swiffSQL-Klasse ein:
PHP, MySQL und Flash
93
Bei jedem Aufruf des PHP-Scripts aus Flash wird eine Variable übergeben ($action). Mögliche Werte sind get (Früchte laden) oder add (Frucht in Datenbank eintragen). Wenn das Script ohne Aktion aufgerufen wird, oder bei der Aktion add kein Name und keine Farbe angegeben wurde, wird das Script beendet. Sie könnten den SQL-String auch aus Flash übergeben. In diesem Fall ist es aber sinnvoller, den SQL-String im Script festzulegen, da die Übergabe ein unnötiges Datenaufkommen wäre. Weiterhin lässt sich so sicher überprüfen, ob wirklich eine Frucht und ein Name angegeben wurden. Machen Sie dies clientseitig, so könnte das PHP-Script auch direkt aufgerufen werden, z.B. mit folgendem String: query.php?sql=INSERT INTO fruits SET fuit='',color='' In diesem Fall würde ein Datensatz ohne Namen und Farbe eingetragen. Dies ist bei einer Überprüfung im PHP-Script nicht möglich. 3. Nachdem der SQL-String definiert wurde, erstellen wir ein neues Objekt der swiffSQLKlasse: //~Neues Objekt der Klasse instanziieren $swiffSQL = new swiffSQL("XML", "database"); //~ Lesen und Schreiben zulassen $swiffSQL->setPermissions(true, true); Diesmal muss aber die Funktion setPermissions() aufgerufen werden, da wir in der Datenbank nicht nur lesen, sondern auch schreiben (einfügen) wollen. 4. Nachdem das Objekt erstellt wurde, senden wir die Anfrage an die Datenbank: //~ Anfrage stellen $swiffSQL->query($sql); Zurückgegeben werden XML-Daten. • Beim Laden der Früchte in der Form:
... • Beim Speichern einer Frucht in der Form: wobei ZAHL in unserem Fall eine Zahl größer 0 sein muss, da wir ein auto_incrementFeld (id) haben. • Bei einem Fehler: <error message="Fehlermeldung" /> DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
94
Kapitel 4
5. Nachdem die Anfrage an die Datenbank gesendet und das Ergebnis ausgegeben wurde (siehe oben), können wir die Verbindung zur Datenbank wieder schließen: //~ Verbindung schließen $swiffSQL->close(); ?> 6. Nun benötigen wir noch die Flash-Seite, mit der die Ausgabe des PHP-Scripts (grafisch) verarbeitet wird. 7. Erstellen Sie zunächst einen neuen Flash-Film und fügen Sie in diesen drei Textfelder ein. Eines dieser Textfelder ist ein dynamisches Textfeld mit der Variable message. In diesem werden die geladenen Früchte angezeigt (deshalb das Textfeld eher hoch als breit und mit Wortumbruch anlegen). Dazu kommen die zwei Texteingabefelder fruit und color. In diese Textfelder muss der Besucher die Frucht bzw. die Farbe, die er in der Datenbank speichern möchte, eintragen. 8. Nun wird noch eine Schaltfläche benötigt, mit welcher der Besucher seine Frucht (und Farbe) an das PHP-Script schicken kann, das die Eintragung vornimmt. Legen Sie diese ebenfalls auf Ebene 0 an. 9. Im ersten Bild des Films legen Sie folgende Variable fest: url = "query.php"; Dies ist der URL zu dem zuvor erstellten Script. Es ist sinnvoll, diese Variable festzulegen, da wir sie an verschiedenen Stellen benötigen. Es wäre selbstverständlich auch möglich, den URL an den jeweiligen Stellen direkt einzufügen. 10. Da jeweils zu Beginn des Scripts und nach dem Einfügen einer Frucht, also an zwei verschiedenen Stellen im SWF, die gesamten sich in der Datenbank befindlichen Früchte angezeigt werden sollen, ist es sinnvoll, diesen Code in einer Funktion unterzubringen. Fügen Sie deshalb ebenfalls im ersten Bild des SWF folgenden Code ein: function getFruits() { //~ Neues XML-Objekt erstellen var myFruits = new XML(); //~ XML-Daten (Früchte und Farben) laden myFruits.load(url+"?action=get"); /*~ Sobald alles geladen wurde, den Prototyp showFruits() aufrufen */ myFruits.onLoad = myFruits.showFruits; } Dieser Code erstellt ein neues XML-Objekt und lädt dann in dieses die Ausgabe des PHP-Scripts (als Aktion wird get angegeben). Sobald die Ausgabe des Scripts vollstän-
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
95
dig geladen wurde, wird der XMLNode-Prototyp showFruits() auf das XML-Objekt mit den geladenen Daten angewandt. Diesen Prototyp müssen Sie ebenfalls einfügen: XMLNode.prototype.showFruits = function () { if (this.firstChild.nodeName == "result") { //~ Daten erfolgreich geladen //~ Alle Früchte und Farben extrahieren var array = this.firstChild.childNodes; for (var k = 0; k < array.length; k++) { //~ durchlaufen und Name+Farbe anzeigen message message message message
+= += += +=
array[k].attributes.fruit; " - "; array[k].attributes.color; "\n";
} //~ end for } else if (this.firstChild.nodeName == "error") { //~ Ein Fehler ist aufgetreten //~ Fehlermeldung ausgeben message = this.firstChild.attributes.text; } //~ end else if } Zuerst wird geschaut, ob der Name des obersten Knotens result oder error ist. Ist der Name error, ist ein Fehler aufgetreten. Dieser wird dann im Textfeld message angezeigt. Ist der Name result, werden alle childNodes (unsere Reihen, also Früchte mit ihren jeweiligen Farben) in einem Array gespeichert und dieses durchlaufen. Bei jedem Element wird der Name (der Frucht) und die Farbe zu dem Textfeld message in der Form Fruchtname – Fruchtfarbe\n hinzugefügt. ·
HINWEIS
Es wäre auch möglich, diesen Prototyp als einfache Funktion zu definieren, allerdings erachte ich es immer als sehr komfortabel, wenn man auf this Zugriff hat; insofern nutze ich diesen Vorteil gerne aus. Sie können aber selbstverständlich auch eine normale Funktion verwenden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
96
Kapitel 4
11. Als Nächstes wird die Funktion benötigt, mit der sich eine Frucht in der Datenbank speichern lässt. Dazu benötigen wir zuerst den Code, der die Frucht inklusive Farbe an das PHP-Script übergibt: function insertFruit(fruit, color) { //~ String, der an das Script übergeben wird string = "?action=add&fruit="+escape(fruit)+"&color="+escape(color); //~ Neues XML-Objekt erstellen var result = new XML(); //~ Ausgabe laden (insert_id oder error) result.load(url+string); /*~ Sobald alles geladen wurde, den Prototyp insertAction() aufrufen */ result.onLoad = result.insertAction; } Zuerst wird der String definiert, der an den URL angehängt wird, die Aktion festlegt und Frucht und Farbe übergibt. Sowohl der Name der Frucht als auch die Farbe werden URL-kodiert. Dies würde der Browser eventuell auch automatisch machen, allerdings ist es sauberer und vermeidet eventuelle Fehler, wenn der String bereits URL-kodiert übergeben wird. Sobald die Ausgabe des Scripts vollständig geladen wurde, wird der XMLNodePrototyp insertAction() auf die geladenen Daten im XML-Objekt result angewandt. Diesen Prototyp müssen Sie einfügen: XMLNode.prototype.insertAction = function () { if (this.firstChild.nodeName == "insert_id") { //~ Frucht korrekt eingefügt //~ Aktualisierte Früchteliste laden getFruits(); } else if(this.firstChild.nodeName == "error") { //~ Beim Einfügen trat ein Fehler auf //~ Fehlermeldung ausgeben message = this.firstChild.attributes.text; } //~ end else if }
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
PHP, MySQL und Flash
97
Zuerst wird überprüft, ob die Frucht korrekt eingefügt wurde (in diesem Fall ist der Name des obersten Elements result) oder ob ein Fehler auftrat (der Name des obersten Elements ist dann error). Wenn ein Fehler auftrat, wird die Fehlermeldung im Textfeld message ausgegeben. Andernfalls wird die Funktion getFruits() aufgerufen und so die aktualisierte Früchteliste aus der Datenbank geladen und dargestellt. Damit beim Start des SWF automatisch die Früchte geladen werden, muss nun noch im ersten Bild der Aufruf getFruits(); eingefügt werden. 12. Damit die Funktion insertFruit() vom Besucher aufgerufen werden kann, sobald er eine neue Frucht (und Farbe) in die vorgesehenen Textfelder eingetragen hat, muss dem zuvor erstellten Textfeld auf Ebene 0 folgender Code zugewiesen werden: on (release) { insertFruit(fruit, color); delete message; delete fruit; delete color; } Dieser Code ruft die Funktion insertFruit() mit den in den Textfeldern eingetragenen Werten auf und löscht diese danach. Das Textfeld, in dem nachher die aktualisierte Fruchtliste (oder ein Fehler) angezeigt wird, sollte ebenfalls geleert werden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
KAPITEL 5
UMGANG MIT FLASH UND PHP
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
100
Kapitel 5
In diesem Kapitel werden einige Probleme beim Umgang mit Flash und PHP angesprochen und Lösungsmöglichkeiten dargeboten. Anhand von einigen Beispielen wird gezeigt, wie sich Flash und PHP elegant und zweckmäßig verbinden lassen.
5.1 Scripts von anderen Servern ausführen/laden Seit dem Flash-Plugin Version 4.0.1.2 ist es nicht mehr möglich, auf Scripts/Dateien von anderen Servern bzw. Domains zuzugreifen, da dies als Sicherheitslücke angesehen wurde. Das heißt: Wenn man ein Script aufrufen möchte, das unter www.meinedomain.de/ script.php liegt, so muss das SWF sich auch unterhalb von meinedomain.de befinden. Es ist nicht möglich, von einem Script, das unter www.meinedomain.de/meinswf.swf liegt, auf ein Script zuzugreifen, das unter www.anderedomain.de/script.php liegt. · HINWEIS
Diese Beschränkung bezieht sich nur auf das Browser-Plugin, im Standalone-Player besteht sie nicht.
Um dennoch auf ein Script, das auf einem anderen Server liegt, zugreifen zu können, gibt es zwei Möglichkeiten:
5.1.1 Proxy-Scripting Ein Beispiel dazu befindet sich im Ordner Beispiele\extRequest\ auf der CD-ROM. Bei dieser Methode ruft das SWF ein PHP-Script auf, das auf der selben Domain liegt. Dieses PHP-Script wiederum kontaktiert das extern liegende Script und gibt dessen Ausgabe an das SWF weiter. Das PHP-Script fungiert somit als »Proxy«-Datenquelle. Eine Funktion, die genau diese Rolle übernimmt, ist Bestandteil der flash.inc.php-Klasse (siehe Kapitel 10). ·
HINWEIS
Bedenken Sie, dass ein PHP-Script, das einen anderen Server kontaktiert, den Server zusätzlich belastet. Das Ausmaß der zusätzlichen Belastung ergibt sich aus der Häufigkeit des Aufrufs und dem Volumen der übermittelten Daten.
5.1.2 DNS-Aliasing DNS (engl: Domain Name System) – Das DNS ist quasi das »Telefonbuch« des Internets. Es dient dazu, die Domainnamen in ihre entsprechenden IP-Adressen umzuwandeln und vice versa.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
101
Bei dieser Methode wird ein DNS-Eintrag angelegt, der ein Alias zu einem externen Server ist. Wenn das SWF den Aufruf zu dem DNS-Alias macht, dann fängt der DNS den URL ab, wertet die Anfrage aus und gibt sie an den extern liegenden Server weiter. ·
HINWEIS
Manche Server lehnen Anfragen von anderen Domains ab, somit ist es möglich, dass eine Fehlermeldung anstelle der erwarteten Variablen zurückgegeben wird. DNS-Einträge für Server außerhalb Ihrer eigenen Domain anzulegen kann problematisch sein. Diese Lösung setzt eine enge Zusammenarbeit mit den Systemadministratoren des extern liegenden Servers voraus, um unerwartetem Verhalten vorzubeugen.
Informationen zum Zugriff auf extern liegende Daten: • Macromedia Technote ID 14213
5.2 SSL mit Flash SSL – (engl.: Secure Sockets Layer) SSL ist eine sichere Übertragungsmethode für Daten im Internet. Für SSL werden Zertifikate für die Gewährleistung der sicheren Übertragung benötigt. Mit diesen Zertifikaten kann man sich beispielsweise sicher sein, wo der Server, auf den man Daten überträgt, steht und wer ihn betreibt. Für ein solches Zertifikat wird ein Zeuge benötigt (z.B. VeriSign – www.verisign.com). Eine solche Bürgschaft kostet Geld – sollten Sie Interesse an einem Sicherheitszertifikat haben, so wenden Sie sich an Ihren ISP, die meisten ISPs bieten für ihre Kunden solche Zertifikate an. Laut Macromedia soll sich Flash bei der Verwendung eines SSL-Servers in Bezug auf die Sicherheit genauso verhalten wie HTML. Man soll sich beim Umgang mit SSL und Flash genauso verhalten wie bei SSL und HTML. Sollten Sie eine Verbindung zu einem sicheren Server aufbauen wollen, so benutzen Sie als Methode POST und einen HTTPS-URL. HTTPS – (engl.: Hypertext transfer protocol secure) Bei einem URL, der mit https:// beginnt, werden die Daten verschlüsselt zum Webserver übertragen. Hierbei wird die Verschlüsselungsmethode SSL (siehe oben) angewandt. Beispiel: //~ ActionScript passwort = "12345"; loadVariablesNum("https://sslserver/daten.php", 0); würde die Variable »passwort« verschlüsselt an den Server (hier: sslserver) übertragen und die Ausgabe auf Ebene 0 laden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
102
Kapitel 5
Informationen zu SSL: • www.ssl.de Informationen zu SSL in Verbindung mit Flash: • Macromedia Technote ID 13931
5.3 Beispiel: Passwortgeschützter Bereich in Flash Dieses Beispiel befindet sich im Ordner Applikationen\flashPass\ auf der CD-ROM. Inhalt des SWF:
Abbildung 5.1: Dieses Bild zeigt den Aufbau der Eingabemaske für passwortgeschützte Daten, die aus einem PHP-Script geladen werden sollen.
Inhalt des PHP-Scripts:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
103
//~ Definition der "geheimen" Daten $geheim = "Ganz geheim!\nExtra für dich ;-)"; //~ verhindern, dass diese Seite im Cache des Browsers gespeichert wird flash::drawExpire(); //~ Sicherstellen, dass Benutzer und Passwort per POST übergeben wurden $user = $HTTP_POST_VARS["user"]; $pass = $HTTP_POST_VARS["pass"]; //~ Überprüfung, ob Benutzer und Passwort eingegeben wurden. if (empty($user) OR empty($pass)) { //~ Passwort oder Benutzer nicht eingegeben flash::echoVar("result", "Bitte geben Sie Ihren Benutzernamen und Ihr Kennwort ein!", true); exit(); //~ Script beenden } else if (!isset($accessArray[$user]) OR $accessArray[$user] != $pass) { //~ Passwort oder Benutzer falsch/nicht vorhanden flash::echoVar("result", "Falsches Passwort/Benutzer", true); exit(); //~ Script beenden } else { //~ alles korrekt, geheime Information ausgeben flash::echoVar("result", $geheim, true); } //~ end if else ?> Es kann sein, dass man innerhalb von Flash bzw. eines SWF einmal Daten benötigt, auf die nur ein oder mehrere bestimmte Benutzer zugreifen dürfen. Dies lässt sich mit Hilfe von Flash allein nicht sicher lösen, da das Passwort irgendwo im SWF gespeichert werden müsste. Da Flash aber eine clientseitige Sprache ist und so der Träger (das SWF) mit dem Benutzer in Berührung kommt, würden auch die im SWF gespeicherten Passwörter dem Besucher zugänglich sein. Es ist ein Leichtes, ein SWF von einer Domain entweder direkt herunterzuladen oder aus dem Cache des Browsers zu holen. Mit einem Hexeditor könnte man dann das SWF begutachten und so Variablen und damit auch die Passwörter aus dem SWF herauslesen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
104
Kapitel 5
Wir müssen also eine Methode finden, bei der die Passwörter nicht mit dem Besucher in Berührung kommen. Dazu eignet sich PHP, da der Quellcode von PHP nur eingesehen werden kann, wenn der Zugriff über das FTP-Protokoll stattfindet. Wenn ein PHP-Script per HTTP aufgerufen wird, dann wird niemals der Quellcode angezeigt werden (dies stellt der Interpreter sicher). Es ist demnach also möglich, die Passwörter bzw. die Benutzer in einem PHP-Script zu speichern und dort zu überprüfen, ob der Benutzer die Berechtigung hat, die Daten abzurufen oder nicht. ·
HINWEIS
Der folgende Entwurf ist lediglich ein Beispiel. Es kann nicht garantiert werden, dass hierbei tatsächlich eine Sicherheitsebene erreicht wird, die den geschützten Daten angemessen ist! Um eine höhere Sicherheitsebene zu erreichen, empfehle ich zusätzlich noch den Einsatz von SSL (siehe Kapitel 5.2).
Der Ablauf ist folgender: 1. Der User wird in Flash mit einer Eingabemaske aufgefordert, seinen Benutzernamen und das dazugehörige Passwort einzugeben. 2. Diese Daten werden an das PHP-Script übermittelt. 3. Im PHP-Script wird überprüft, ob der Benutzer gültig ist und ob das Passwort zu diesem Benutzer mit dem eingegebenen übereinstimmt. 4. Je nach Ergebnis wird entweder eine Fehlermeldung oder die geheimen Daten zurückgegeben. 5. Die Rückgabe wird in einem Textfeld des SWF angezeigt. Aufbau der Applikation: 1. Erstellen Sie einen neuen Flash-Film. 2. Fügen Sie direkt im ersten Bild ein Texteingabefeld für den Benutzernamen ein, wählen Sie als Linientyp »Eine Zeile« und nennen Sie ihn user. Denken Sie daran, dass in PHP anders als in Flash Variablen case-sensitive sind, d.h. es wird zwischen Groß- und Kleinschreibung unterschieden. Fügen Sie ein weiteres Texteingabefeld ein, wählen Sie diesmal als Linientyp »Kennwort«. Wählen Sie bei diesem Feld als Variable pass. Nun benötigen wir noch das Textfeld für die Ausgabe der Fehlermeldungen bzw. der geheimen Daten. Fügen Sie hierzu ein mehrzeiliges Textfeld ein und nennen Sie es result. 3. Jetzt können die Daten vom Besucher eingegeben werden. Aber zur Übergabe der Daten an das PHP-Script und die Rückgabe des Ergebnisses wird noch folgender Code auf einer Schaltfläche benötigt:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
105
//~ ActionScript on (release, keyPress "<Enter>") { delete result; loadVariablesNum("checkPass.php", 0, "POST"); } Wenn die Schaltfläche angeklickt oder die Enter-Taste gedrückt wird, wird das Ergebnis, das eventuell von einem vorherigen Fehlschlag geladen worden wäre, gelöscht und die Daten in den Textfeldern erneut an das PHP-Script (hier: checkPass.php) übertragen. Beachten Sie hierbei, dass als Übertragungsmethode POST angegeben wurde. Dies ist extrem wichtig, da bei der GET-Methode das Passwort und der Benutzername an den URL angehängt würden und somit eventuell aus dem Cache des Browsers von Unbefugten extrahiert werden könnten. Ein weiterer Grund dafür, hier die POST-Methode zu verwenden, ist, dass dann die Benutzerdaten auch nicht von Proxies zwischengespeichert werden und somit nicht in Hände von Dritten fallen können. · HINWEIS
Sollten Sie ein noch höheres Maß an Sicherheit benötigen, so schauen Sie sich bitte Kapitel 5.2 an.
4. Nachdem das SWF nun fertig ist, widmen wir uns dem PHP-Script. Erstellen Sie hierzu eine neue PHP-Datei (hier: checkPass.php). Binden Sie zuerst die Klassendatei von flash.inc.php ein, damit Sie auf deren Funktionen zugreifen können: include("./includes/flash.inc.php"); · HINWEIS
Die Klasse flash.inc.php und ihre Funktionen sind in Kapitel 10 näher beschrieben.
5. Als Nächstes legen wir die Benutzer mit ihren Passwörtern fest, die auf die geschützten Daten Zugriff haben sollen: $accessArray = array(); Es ist immens wichtig, dass dieses Array neu definiert wird. Man könnte auch Benutzer zum Array hinzufügen, ohne vorher die Variable $accessArray dem Typ »Array« zugeordnet zu haben. Dies würde allerhöchstens eine Warnung produzieren. Sollten Sie das Array jedoch nicht bei jedem Aufruf des PHP-Scripts neu definieren, so ließen sich an den URL des PHP-Scripts neue Arrayelemente anhängen, etwa so: http://server/checkPass.php?accessArray[hacker]=trick&user=hacker&pass=trick Schon käme der Hacker an die geschützten Daten heran, ohne dass er überhaupt einen Benutzernamen oder ein Passwort kennt. Gehen Sie nicht davon aus, dass niemand die Art der Benutzerspeicherung (also das Array) erraten wird, sondern stellen Sie sicher, dass Daten aus der Umwelt (dem Internet bzw. dem Hacker) nicht die Daten in Ihrem PHP-Script auf ungewollte Weise manipulieren. Um die Benutzer zu definieren, benötigen wir folgenden Code:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
106
Kapitel 5
$accessArray["Joscha"] = "X"; $accessArray["User2"] = "Passwort2"; $accessArray["User3"] = "PASSwort3"; Das Array wird in der Form $accessArray["Benutzername"] = "Passwort"; definiert. Sollten Sie einen weiteren Benutzer hinzufügen wollen, so können Sie diesen inklusive Passwort einfach mit einer weiteren Zeile derselben Form definieren. Benutzernamen und Passwörter sind case-sensitive, d.h. es wird sowohl im Namen als auch im Passwort nach Groß- und Kleinschreibung unterschieden. 6. Als Nächstes definieren wir die geschützte Information: $geheim = "Ganz geheim!\nExtra für dich ;-)"; Diese Information könnte selbstverständlich auch aus einer Datenbank oder einer anderen Datenquelle kommen. Sie ist hier nur der Einfachheit des Beispiels wegen direkt in PHP definiert. 7. Da es sich bei diesem PHP-Script um sensible Daten handelt, fügen wir folgenden Befehl hinzu: flash::drawExpire(); Dieser Befehl verhindert, dass die Ausgabe des Scripts von Proxies und/oder im Cache des Besuchers gespeichert wird. Dies ist wichtig, da bei einem erfolgreichen Login die geschützten Daten zurückgegeben werden und diese nicht aus dem Cache extrahiert werden dürfen. 8. Nun können wir beginnen, die vom Besucher übergebenen Daten zu überprüfen und im Falle eines Fehlschlags eine Fehlermeldung oder bei Erfolg die geschützten Daten auszugeben. //~ Überprüfung, ob Benutzer und Passwort eingegeben wurden. if (empty($user) OR empty($pass)) { //~ Passwort oder Benutzer wurden nicht eingegeben flash::echoVar("result", "Bitte geben Sie Ihren Benutzernamen und Ihr Kennwort ein!", true); exit(); //~ Script beenden } else if (!isset($accessArray[$user]) OR $accessArray[$user] != $pass) { //~ Passwort oder Benutzer falsch/nicht vorhanden flash::echoVar("result", "Falsches Passwort/Benutzer", true); exit(); //~ Script beenden
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
107
} else { //~ alles korrekt, "geheime" Daten ausgeben flash::echoVar("result", $geheim, true); } //~ end if else In der ersten if-Abfrage wird geprüft, ob die Variablen $user und $pass überhaupt einen Inhalt haben. Wenn eine oder beide Variablen keinen Inhalt haben, dann wird eine Fehlermeldung ausgegeben. Bei der zweiten if-Abfrage wird geprüft, ob der eingegebene Benutzer überhaupt gültig ist, und wenn ja, ob das eingegebene Passwort mit dem des Benutzers übereinstimmt. Wenn beide Bedingungen erfüllt sind, werden die geschützten Daten ausgegeben, ansonsten wird eine Fehlermeldung generiert. ·
HINWEIS
Geben Sie in der Fehlermeldung immer an, dass sowohl der Benutzername als auch das Passwort falsch sein können. Schränken Sie den Fehler nicht weiter ein, da sonst unbefugte Personen bei einem bekannten Benutzernamen nur noch Passwörter ausprobieren müssen.
Sie sehen, dass nach der Ausgabe der Fehlermeldungen das Script sofort beendet wird. Dies ist nicht unbedingt nötig, da auch bei weiterer Ausführung die Bedingungen die Ausgabe der geschützten Daten verhindern würden. Allerdings ist es überflüssig, bei einer Fehlermeldung weitere Überprüfungen vorzunehmen, da eventuelle Fehler bei der Eingabe so oder so zuerst behoben werden müssen.
5.4 Beispiel: Sessions mit Flash und PHP Dieses Beispiel befindet sich im Ordner Applikationen\flashSession\ auf der CD-ROM. Inhalt des PHP-Scripts:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
108
Kapitel 5
Inhalt des SWF
Abbildung 5.2: Dieses Bild zeigt den Aufbau eines SWF, in dem zuerst eine Sprache festgelegt und dann später mit der Session-ID ein der Sprache entsprechender Text geladen oder die Session beendet werden kann.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
109
if ($action == "create") { //~ Neue Session erstellen //~ Statusmeldungen definieren $messageArray[0] = "Session konnte nicht gestartet werden."; $messageArray[1] = "Session gestartet."; $messageArray[2] = "Sprache nicht definiert!"; $language = $HTTP_GET_VARS["language"]; if (empty($language)){ //~ Sprache nicht definiert flash::echoVar("result", 0); flash::echoVar("message", $messageArray[2], true); exit(); //~ Script beenden } //~ end if //~ Neue Session-Variable hinzufügen session_register("s_language"); //~ Wert der Session-Variable ändern $HTTP_SESSION_VARS["s_language"] = $language; $s_language = $language; //~ Ausgabe des Status flash::echoVar("result", $result); //~ Ausgabe des Sessionnamens flash::echoVar("_SNAME",session_name(), false); //~ Ausgabe der Session-ID flash::echoVar("_SID",session_id(), false); //~ Ausgabe der Statusmeldung flash::echoVar("message", $messageArray[$result], true); } else if ($action == "get") { //~ Text ausgeben, abhängig von der zuvor gesetzten Sprache //~ Deutschen und englischen Text definieren $messageArray["de"] = "Dies ist der deutsche Text."; $messageArray["en"] = "This is the english text."; $messageArray[""] = "Session nicht aktiv!"; //~ Text in der gewählten Sprache ausgeben flash::echoVar("message", $messageArray[$HTTP_SESSION_VARS["s_language"]], true);
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
110
Kapitel 5
} else if ($action == "destroy") { //~ Session beenden //~ Statusmeldungen definieren $messageArray[0] = "Zerstörung fehlgeschlagen!"; $messageArray[1] = "Session wurde gelöscht!"; //~ Session zerstören $result = session_destroy(); //~ Ausgabe der Statusmeldung flash::echoVar("message", $messageArray[$result], true); } else { //~ Keine Aktion definiert //~ Statusmeldung definieren $messageArray[0] = "Aktion nicht definiert!"; //~ Statusausgabe flash::echoVar("result", 0); //~ Ausgabe der Statusmeldung flash::echoVar("message", $messageArray[0]); } //~ end no correct action ?> ·
HINWEIS
In diesem Beispiel werden die Session-Funktionen von PHP verwendet. Diese sind ab PHP Version 4 verfügbar. Es ist möglich, die Session-Funktionen zu benutzen, ohne die Session-Daten an PHP-Scripts anzuhängen, da die Session Engine von PHP Cookies benutzt. Da aber nicht alle Benutzer Cookies aktiviert haben, wird in diesem Beispiel nur darauf eingegangen, wie man die Session-Funktionen ohne die Verwendung von Cookies einsetzt.
Globale Variablen in Flash
Exkurs
Es gibt in Flash (4/5) keine globalen Variablen, d.h. es ist nicht möglich, eine Variable so zu definieren, dass man überall direkt auf sie zugreifen kann. Angenommen, Sie definieren eine Variable variable auf Ebene 0, dann können Sie innerhalb einer Filmsequenz auf diese Variable nicht direkt zugreifen, sondern müssen den Pfad voranstellen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
111
Beispiel: //~ ActionScript Exkurs
//~ Man befindet sich z.B. in einer Filmsequenz, //~ auf Ebene 0 ist die Variable "variable" definiert. //~ mit dem Code trace(variable); //~ kann ihr Inhalt nicht ausgegeben werden, mit trace(_root.variable); //~ hingegen schon. Das heißt, es gibt zwar keine globalen Variablen, aber man kann auf alle Variablen global zugreifen (solange man ihren genauen Pfad kennt).
Der Ablauf ist folgender: 1. In Flash wählt der Besucher eine Sprache (Englisch oder Deutsch) und startet dann die Session. 2. Die Session-Daten werden vom PHP-Script an das SWF zurückgegeben. 3. Danach kann mit der Session-ID, die an ein PHP-Script übergeben wird, herausgefunden werden, welche Sprache der Besucher zuvor gewählt hat, und anhand dieser Information ein Text in der entsprechenden Sprache geladen werden. 4. Bei Bedarf kann die Session beendet werden. Aufbau der Applikation: 1. Erstellen Sie einen neuen Flash-Film mit drei Ebenen mit jeweils zwei Bildern. 2. Erstellen Sie in der dritten Ebene ein Textfeld mit der Variable message. Dies wird benötigt um Statusmeldungen auszugeben. 3. Fügen Sie in der ersten Ebene eine leere Filmsequenz ein. Benennen Sie diese eindeutig (hier: _SESS). Welchen Namen Sie der Filmsequenz geben, ist nicht wichtig, allerdings werden in dieser Filmsequenz später die Session-Daten gespeichert. Somit ist es sinnvoll, einen eindeutigen und kurzen (da Sie eventuell oft darauf zugreifen müssen) Namen zu geben. Fügen Sie zu dieser Filmsequenz folgenden Code hinzu: //~ ActionScript onClipEvent (data) { _root.message = message; delete message;
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
112
Kapitel 5
if (result == true) { _root.gotoAndPlay (2); } //~ end if delete result; } //~ end onClipEvent(data) Dieser Code bewirkt, dass nach dem vollständigen Laden von Daten in diese Filmsequenz die Statusmeldung in dem Textfeld, das wir auf der dritten Ebene erstellt haben, ausgegeben wird. Danach wird die Statusmeldung gelöscht, da sie nicht länger benötigt wird. Die if-Abfrage bewirkt, sollte der vom PHP-Script zurückgegebene Status true (wahr) sein, dass auf der Hauptzeitleiste ein Bild weiter gesprungen wird. Danach wird die Statusvariable (result) gelöscht. Wenn der Status true (wahr) ist, enthält die Filmsequenz auch die Session-Daten, die später benötigt werden. 4. Ändern Sie nun das zweite Bild auf der zweiten Ebene in ein Schlüsselbild um, in das Sie eine stop()-Aktion einfügen. Im ersten Bild fügen Sie folgenden Code ein: //~ ActionScript MovieClip.prototype.getString = function () { var authString = this._SNAME+"="+this._SID; return authString; }; // ~ end function getString stop (); Der Filmsequenz-Prototyp gibt, wenn er aufgerufen wird, einen String zurück, der die Session-Daten enthält, die an das PHP-Script angehängt werden müssen. Der String sieht der Form nach so aus: PHPSESS=7a9659221e0693185ae4a4249c875ce2 Er wird aus den zuvor vom PHP-Script übergebenen Session-Daten generiert. Wenn Sie die Ausgabe des PHP-Scripts bzw. die Variablen verändern oder diese innerhalb des SWF an anderer Stelle als in einer Filmsequenz speichern, dann müssen Sie diesen Prototyp entsprechend anpassen. 5. Ebenfalls im ersten Bild der zweiten Ebene fügen Sie drei Schaltflächen ein, zwei zur Auswahl der Sprache, nämlich eine für die Sprache Deutsch und eine für Englisch. Die dritte Schaltfläche dient zum Starten der Session. Der Schaltfläche für Deutsch weisen Sie folgenden Code zu:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
113
on (release) { message = "Deutsch"; language = "de"; } Der Schaltfläche für Englisch weisen Sie folgenden Code zu: on (release) { message = "Englisch"; language = "en"; } Der Schaltfläche zum Starten der Session weisen Sie folgenden Code zu: on (release) { _SESS.loadVariables("flashSession.php?action=create&language="+language); delete language; } Dieser Code übergibt dem Script die gewählte Sprache und die Aufforderung, die Session einzuleiten. Die Rückgabe des Scripts wird in die vorher erstellte Filmsequenz _SESS auf Ebene 0 geladen. Die Information, welche Sprache gewählt wurde, wird entfernt, da sie nicht länger benötigt wird. 6. Im zweiten Frame der zweiten Ebene benötigen wir zwei Schaltflächen, eine, um den Text zu laden, und eine, um die Session zu beenden. Weisen Sie dem Button für das Laden des Textes folgenden Code zu: on (release) { loadVariablesNum("flashSession.php?action=get&"+_SESS.getString(), 0); } Dieser Code übergibt dem PHP-Script die Session-Daten, die mit der Funktion getString() aus dem Container (der Filmsequenz _SESS) in einen String umgewandelt und dann an das Ende des URL zusammen mit der Aktion angehängt werden. Die Ausgabe des Scripts wird auf Ebene 0 geladen und der Text im Textfeld message angezeigt. Der Button, um die Session zu beenden, benötigt folgenden Code: on (release) { loadVariablesNum("flashSession.php?action=destroy&"+_SESS.getString(), 0); } DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
114
Kapitel 5
Bei diesem Aufruf werden dem Script ebenfalls die Session-Daten angehängt, die Aktion ist aber, die Session zu beenden. Es wird eine Statusmeldung zurückgegeben, die im Textfeld message auf Ebene 0 angezeigt wird. 7. Nachdem das SWF nun fertig gestellt ist, wenden wir uns dem PHP-Script zu. Zuerst müssen Sie die flash.inc.php-Klasse einbinden, um Zugriff auf deren Funktionen zu bekommen. Näheres zu flash.inc.php erfahren Sie in Kapitel 10. Danach senden Sie die Information für Browser und Proxies, die Ausgabe des Scripts nicht im Cache zu speichern. Dies ist wichtig, da das Script eventuell sehr oft aufgerufen wird.
Die Funktion session_start() bool session_start (void) Die Funktion session_start() benötigt keine Argumente. Tutorial
Sie leitet entweder eine neue Session ein oder nimmt eine bereits begonnene Session wieder auf. Zurückgegeben wird immer true (wahr). ·
HINWEIS
Wenn Sie Cookies zum Speichern der Session-Variablen (Session-ID und Session-Name) verwenden möchten, so muss der Aufruf von session_ start() immer vor jeglicher anderer Ausgabe geschehen! Die Funktionen session_register() leitet die Session automatisch ein, wenn sie vor session_start() aufgerufen wird.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
115
Da das PHP-Script drei Aktionen hat – eine, um die Session zu starten, eine, um einen Text zurückzugeben, und eine, um die Session zu schließen – benötigen wir drei Blöcke (und einen, um einen Fehler auszugeben, falls keine Aktion definiert wurde): if ($action == "create") { //~ Neue Session erstellen } else if ($action == "get") { //~ Text ausgeben } else if ($action == "destroy") { //~ Session beenden } else { //~ Keine Aktion definiert } //~ end no correct action 8. Der erste Block erstellt eine neue Session und legt die Sprache des Besuchers fest. Der Ablauf im Einzelnen: Zuerst werden die verschiedenen Statusmeldungen definiert. Diese werden benötigt, um dem Besucher mitzuteilen, was gerade geschieht (in einem echten Projekt würden höchstwahrscheinlich nur Statuscodes übergeben, da der Besucher nicht zu wissen braucht, dass eine neue Session eingeleitet wurde etc. Hier aber – um besser zu verdeutlichen, was geschieht – ist es sinnvoll, Statusmeldungen auszugeben). Fügen Sie nach if ($action == "create") { folgenden Code ein: //~ Statusmeldungen definieren $messageArray[0] = "Session konnte nicht gestartet werden."; $messageArray[1] = "Session gestartet."; $messageArray[2] = "Sprache nicht definiert!"; Dann wird überprüft, ob der Benutzer auch eine Sprache gewählt hat. Wenn nicht, wird eine Statusmeldung und ein Statuscode ausgegeben und danach das Script beendet: //~ Überprüfen, ob eine Sprache gewählt wurde if (empty($language)){ //~ Sprache nicht gewählt flash::echoVar("result", 0); flash::echoVar("message", $messageArray[2], true);
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
116
Kapitel 5
exit(); //~ Script beenden } //~ end if Sollte der Benutzer die Sprache gewählt haben, wird eine neue Variable in der Session registriert. Dies geschieht mit session_register(): //~ Neue Session-Variable hinzufügen session_register("s_language");
Die Funktion session_register() bool session_register (mixed name [, mixed ...])
Tutorial
Mit der Funktion session_register() kann man eine oder mehrere Variablen verschiedenen Typs (also nicht nur Variablen, sondern auch Arrays) in der Session speichern, die bei der Wiederaufnahme derselben Session dann wieder zur Verfügung stehen. In unserem Fall speichern wir die gewählte Sprache des Besuchers in der Session, um später erkennen zu können, in welcher Sprache dem Besucher der Text ausgegeben werden soll. Zurückgegeben wird von der Funktion entweder true (wahr), wenn die Variable erfolgreich registriert wurde, oder false (falsch), wenn die Registrierung fehlschlug. Nachdem die neue Variable registriert wurde, kann man ihren Inhalt verändern: //~ Wert der Session-Variable ändern $HTTP_SESSION_VARS["s_language"] = $language; · HINWEIS
Es gibt zwei Möglichkeiten, wie Session-Variablen in PHP gehandhabt werden. Welche Methode zu verwenden ist oder verwendet werden kann, hängt von der PHP-Konfiguration ab.
Wenn in der php.ini der Wert register_globals auf on gestellt wurde, dann kann man auf die Session-Variablen wie auf normale Variablen zugreifen: Beispiel: DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
117
Wenn register_globals nicht aktiviert ist, sondern nur track_vars, dann kann auf die Variablen nicht direkt zugegriffen werden, sondern nur über das Array $HTTP_SESSION_VARS: Tutorial
Beispiel: Ist sowohl register_globals als auch track_vars aktiviert, so bezeichnen die globalen Variablen und die Variablen im Array $HTTP_SESSION_VARS denselben Wert. · HINWEIS
Die Konfiguration hinsichtlich register_globals und track_ vars kann nur vom Administrator verändert werden.
9. Nachdem nun die Session gestartet und die Sprache wie folgt festgelegt wurde: //~ Wert der Session-Variable ändern $HTTP_SESSION_VARS["s_language"] = $language; $s_language = $language; müssen die Session-Daten noch an das SWF zurückgegeben werden. Die Session-Daten werden auch in einem Cookie auf dem Rechner des Besuchers abgelegt, wenn diese Funktion in der php.ini aktiviert wurde. Allerdings ist es möglich, dass der Besucher keine Cookies annimmt. Dann würde der weitere Ablauf fehlschlagen. Um also zu gewährleisten, dass die Session-Daten immer übergeben werden, müssen sie an das SWF übergeben werden. Dies geschieht mit folgendem Code: //~ Ausgabe des Status flash::echoVar("result", $result); //~ Ausgabe des Session-Namens flash::echoVar("_SNAME", session_name(), false); //~ Ausgabe der Session-ID flash::echoVar("_SID", session_id(), false); //~ Ausgabe der Statusmeldung flash::echoVar("message", $messageArray[$result], true);
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
118
Kapitel 5
Die Ausgabe sieht etwa so aus (andere Session-ID und evtl. anderer Session-Name): &result=1& &_SNAME=PHPSESSID& &_SID=5ec4284761796b329890949d6324e449& &message=Session+gestartet.& Zuerst wird der Statuscode ausgegeben (result). Dieser zeigt, ob alles korrekt abgelaufen ist. Dann folgen der Session-Name (_SNAME), dann die Session-ID (_SID) und dann eine Statusmeldung (message). 10. Nun benötigen wir den Code für den nächsten Block. In diesem wird ein Text ausgegeben, der je nach ausgewählter Sprache entweder englisch oder deutsch ist. Es wird aber nicht die Sprache übergeben, sondern nur die Session-Daten. In diesem Fall gibt es noch ein Missverhältnis zwischen der Datenlänge, d.h. es wäre schneller bzw. kürzer, die Sprache zu übergeben. Bei großen Projekten allerdings wird höchstwahrscheinlich nicht nur die Sprache gespeichert, sondern eventuell noch andere Informationen, wie z.B. Benutzername, Passwort etc. Da dies hier aber ein Beispiel ist und das Prinzip das gleiche bleibt, egal wie viele Daten in der Session gespeichert werden, ist das nicht von Relevanz. Fügen Sie also nach } else if ($action == "get") { folgenden Code ein: //~ Deutschen und englischen Text definieren $messageArray["de"] = "Dies ist der deutsche Text."; $messageArray["en"] = "This is the english text."; $messageArray[""] = "Session nicht aktiv!"; //~ Text in der gewählten Sprache ausgeben flash::echoVar("message", $messageArray[$HTTP_SESSION_VARS["s_language"]], true); Zuerst werden die zwei verschiedenen Texte definiert. Diese können auch aus einer anderen Quelle stammen, hier jedoch werden sie der Einfachheit halber innerhalb des PHP-Scripts definiert. Danach wird der entsprechende Text ausgegeben. Die Variable $s_language enthält die zuvor gewählte Sprache des Besuchers. Sie ist nun wieder verfügbar, und anhand von ihr wird entschieden, welcher der beiden Texte ausgegeben wird. 11. Nun wird noch der Block benötigt, mit dem die Session beendet bzw. gelöscht werden kann. Fügen Sie hierzu nach } else if ($action == "destroy") { folgenden Code ein:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
119
//~ Statusmeldungen definieren $messageArray[0] = "Zerstörung fehlgeschlagen!"; $messageArray[1] = "Session wurde zerstört!"; //~ Session zerstören $result = session_destroy(); //~ Ausgabe der Statusmeldung flash::echoVar("message", $messageArray[$result], true); Zuerst werden die Statusmeldungen definiert, dann wird die Session mit session_ destroy()zerstört und anschließend das Ergebnis bzw. die entsprechende Statusmeldung ausgegeben.
Die Funktion session_destroy() bool session_destroy (void)
Tutorial
Diese Funktion löscht bzw. beendet eine Session und löscht alle Daten, die mit dieser zusammenhängen. Zurückgegeben wird im Erfolgsfall true (wahr) und falls das Löschen fehlschlug, false (falsch). Argumente gibt es keine, wichtig ist, dass die Session, die zerstört werden soll, vorher eingeleitet wurde, ansonsten schlägt das Beenden der Session fehl.
12. Zuletzt benötigen wir noch den Block, der ausgegeben wird, wenn beim Aufruf des Scripts keine Aktion angegeben wurde. Fügen Sie hierzu nach } else { folgenden Code ein: //~ Statusmeldung definieren $messageArray[0] = "Aktion nicht definiert!"; //~ Statusausgabe flash::echoVar("result", 0); //~ Ausgabe der Statusmeldung flash::echoVar("message", $messageArray[0]); } //~ end no correct action Dieser Code gibt eine Fehlermeldung an das SWF aus, sollte beim Aufruf keine Aktion angegeben worden sein.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
120
Kapitel 5
Dieses Projekt bzw. diese Applikation ist nur ein Beispiel für den Umgang mit Sessions. In einem richtigen Projekt werden die Aktionen, die hier über Schaltflächen ausgelöst werden, eher vom Programmierer festgelegt und ohne Zutun des Besuchers ausgelöst. Um aber die Funktionsweise und vor allem den Umgang mit Session-Daten innerhalb von Flash zu demonstrieren, eignet sich dieses Beispiel gut. Der Ablauf in einem Projekt wäre wohl eher folgender: 1. Der Besucher kommt auf der Webseite an; es wird automatisch eine Session gestartet. 2. Dann wählt der Besucher seine Sprache. 3. Im weiteren Verlauf werden bei allen Aufrufen an externe PHP-Scripts die SessionDaten übergeben, und so wird erkannt, in welcher Sprache die Daten zurückgegeben werden müssen (beispielsweise bei einem Menü oder einem Produktkatalog). 4. Die Session wird eventuell nicht explizit beendet, sondern automatisch entfernt, wenn keine Interaktion vom Besucher mehr kommt.
5.5 Beispiel: Besucherzähler mit PHP und Flash Dieses Beispiel befindet sich im Ordner Applikationen\swfCount\ auf der CD-ROM. Inhalt des SWF:
Abbildung 5.3: Dieses SWF ruft ein PHP-Script auf, das in einer Datei auf dem Server die Aufrufe zählt. So lässt sich ein einfacher Besucherzähler mit Flash und PHP realisieren.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
121
Inhalt des PHP-Scripts:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
122
Kapitel 5
//~ Dateizeiger auf den Beginn der Datei setzen fseek($filePointer, 0); //~ Neue Besucherzahl in die Datei schreiben fwrite($filePointer, $count); //~ Sperrung aufheben flock($filePointer, 3); } //~ end if //~ Datei schließen fclose($filePointer); //~ Besucherzahl im Flash-Format ausgeben flash::echoVar("count", $count); ?> Der Ablauf ist folgender: 1. Das SWF ruft beim Start ein PHP-Script auf. 2. Dieses PHP-Script liest die bisherige Besucherzahl aus einer Datei, erhöht diese Zahl um eins, speichert sie in der Datei und gibt sie in Flash-kompatiblem Format aus. 3. Diese Ausgabe wird von Flash geladen und die Besucherzahl in einem Textfeld angezeigt. ·
HINWEIS
Da es sich bei dieser Applikation um ein Beispiel handelt, wurde auf die Ausgabe von Fehlermeldungen verzichtet. Vor dem Einsatz sollten Sie zunächst das Script im Browser direkt aufrufen, um eventuelle Fehlermeldungen sehen zu können.
Aufbau der Applikation: 1. Erstellen Sie einen neuen Flash-Film mit zwei Ebenen. 2. Auf der einen Ebene erstellen Sie ein dynamisches Textfeld mit der Variable showCount. Dies ist das Textfeld, in dem später die Besucherzahl ausgegeben wird. 3. Auf der anderen Ebene fügen Sie eine (leere) Filmsequenz ein, die folgenden Code enthält: //~ ActionScript onClipEvent (load) { loadVariables("swfCount.php", this); } DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
123
onClipEvent (data) { _root.showCount = "Sie sind Besucher # "+count; } Der erste onClipEvent ruft das Script swfCount.php beim Start der Filmsequenz auf und lädt dessen Ausgabe in die Filmsequenz. Der zweite onClipEvent gibt die Besucherzahl zusammen mit dem kurzen Text auf Ebene 0 aus, sobald die Besucherzahl komplett geladen wurde. · BEISPIEL
Waren z.B. bereits 22 Besucher auf der Seite (inklusive des momentanen Besuchers), dann ist die Ausgabe folgende: Sie sind Besucher # 22
4. Aufbau des PHP-Scripts: Zu Beginn muss die flash.inc.php-Klasse eingebunden werden, um auf ihre Funktionen zugreifen zu können. Danach müssen Sie die Anweisung an Browser und Proxies senden, die Ausgabe des Scripts nicht zu cachen. Dies ist wichtig, falls einer der Besucher in naher Zukunft wieder auf Ihre Seite gelangen sollte. Es wird dadurch sichergestellt, dass er immer die aktuellste Besucherzahl bekommt. Zuletzt muss noch eine Datei definiert werden, in der die Besucherzahl gespeichert wird:
CHMOD – Rechte unter Linux vergeben chmod – (engl.: change mode = Modus ändern) chmod heißt der Befehl unter Linux, um die Rechte einer Datei oder eines Ordners zu ändern. Exkurs
Anmerkung: Dieser Exkurs ist nur für die Arbeit unter Linux etc. wichtig, unter Windows ist der Inhalt dieses Exkurses hinfällig, da das Rechtesystem ein anderes ist. Für cgi-Scripts beispielsweise ist es unbedingt nötig, die Rechte des Scripts korrekt zu setzen, damit sie ausgeführt werden können. Bei PHP-Scripts muss das Script selbst zwar nicht bestimmte Rechte bekommen, sobald ein DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
124
Kapitel 5
Exkurs
PHP-Script jedoch mit dem Dateisystem zu tun hat (vor allem beim Schreiben/Erstellen von Dateien und Ordnern) muss man sich zwangsläufig mit dem Rechtesystem von Linux oder anderen Unix-Derivaten auseinander setzen. User/Owner (Eigentümer)
Group (Gruppe)
Others/Public (Öffentlichkeit)
Lesen (4)
x
x
x
Schreiben (2)
x
Ausführen (1)
x
x
x
(4+2+1) = 7
(4+1) = 5
(4+1) = 5
Insgesamt:
In diesem Fall würde das Script vom Eigentümer gelesen, geschrieben und ausgeführt werden können. Alle anderen können es nur lesen und ausführen, aber nicht ändern. • Was bedeuten diese CHMOD-Nummern? 0: keine Rechte 1: nur ausführen 2: nur schreiben 3: lesen und schreiben 4: nur lesen 5: lesen und ausführen 6: lesen und schreiben 7: lesen, schreiben und ausführen • Beispiele bei Dateien: 777: Alle können lesen, schreiben und ausführen. 755: Der Eigentümer kann alles, alle anderen können nur lesen und ausführen. 644: Der Eigentümer kann lesen und schreiben, alle anderen können nur lesen. • Beispiele bei Verzeichnissen: 777: Alle können lesen, schreiben und suchen. 755: Der Eigentümer kann alles, andere können nur suchen. • Beispiele für typische Einstellungen: cgi-Scripts: 755 (z.B. Perl-Scripts) Datendateien: 666 (wie z.B. unsere Datei, um die Besucher zu zählen) Konfigurationsdateien: 644 (Dateien, die nicht durch Scripts aktualisiert werden) Ordner: 777 (mit korrekten Zugriffsrechten der Dateien) • Tipp: Wenn Sie den Modus eines Scripts auf 400 ändern, dann wird es deaktiviert (der Eigentümer hat noch Leserecht, alle anderen haben keinerlei Rechte). Sie können es jederzeit wieder in einen anderen Modus bringen, um es zu reaktivieren. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
125
5. Der nächste Schritt besteht darin, einen Dateizeiger zu erstellen, der uns in der gewünschten Speicherdatei die bisherige Besucherzahl lesen und dann die neue Besucherzahl speichern lässt. Hierzu müssen wir überprüfen, ob die Datei, in der wir lesen bzw. schreiben wollen, überhaupt existiert, und je nachdem den Dateizeiger erstellen: //~ Überprüfen, ob Speicherdatei bereits vorhanden ist if (!file_exists($countFile)) { //~ Datei existiert noch nicht //~ Datei im Modus für Lesen und Schreiben öffnen //~ Da Datei nicht existiert, neu anlegen $filePointer = fopen($countFile, "w+"); //~ Zugriffsrechte festlegen: //~ Alle dürfen die Datei lesen und schreiben chmod($countFile, 0666); } else { //~ Datei existiert bereits //~ Datei zum Lesen und Schreiben öffnen $filePointer = fopen($countFile, "r+"); } //~ end if
Die Funktion file_exists() bool file_exists (string filename)
Tutorial
Die Funktion file_exists() nimmt als Argument einen Dateinamen bzw. einen Pfad zu einer Datei. Wenn die Datei existiert, wird true (wahr) zurückgegeben, wenn sie nicht existiert, liefert die Funktion den Wert false (falsch) zurück.
Mit file_exists() wird überprüft, ob die Datendatei bereits existiert. Wenn die Datei noch nicht existiert, wird versucht, sie anzulegen und zum Lesen und zum Schreiben zu öffnen. Wenn die Datei noch nicht existierte, ist es sinnvoll, die Dateirechte gleich korrekt zu setzen. In diesem Fall wird der Modus der Datei auf 666 geändert, was typisch für eine Datendatei ist (siehe Exkurs zu chmod() oben). Wenn die Datei bereits existiert, wird sie zum Lesen und Schreiben geöffnet, ihre Dateilänge allerdings nicht auf 0 zurückgesetzt, da ja sonst die bereits gespeicherte Besucheranzahl verloren ginge. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
126
Kapitel 5
Nachdem der Dateizeiger erstellt worden ist, kann in der Datei sowohl gelesen als auch geschrieben werden. 6. Da ein Besucherzähler (je nach Besucherzahlen) oft bis sehr oft aufgerufen wird, ist es sinnvoll, die Datendatei während des Schreibens für andere Zugriffe zu sperren, da es sonst bei zeitgleichem Zugriff mehrerer Instanzen des Scripts zu einer Beschädigung der Datendatei kommen kann. //~ Datei zum Schreiben (und Lesen) sperren if (flock($filePointer, 2)) { //~ Datei wurde noch nicht gesperrt //~ Dateiinhalt lesen $count = fread($filePointer, filesize($countFile)); //~ Gelesene Besucherzahl um eins erhöhen $count++; //~ Dateiinhalt löschen ftruncate($filePointer, 0); //~ Dateizeiger auf den Beginn der Datei setzen fseek($filePointer, 0); //~ Neue Besucherzahl in die Datei schreiben fwrite($filePointer, $count); //~ Sperrung aufheben flock($filePointer, 3); } //~ end if Mit der Funktion flock() wird überprüft, ob die Datei bereits gesperrt ist (in diesem Fall würde nicht in die Datei geschrieben werden), und eventuell eine Sperrung für exklusives Schreiben erstellt. Gibt flock() true (wahr), also eine Bestätigung für eine erfolgreiche Sperrung zurück, so wird der momentane Dateiinhalt gelesen (das ist die bisherige Besucherzahl) und in der Variable $count gespeichert. Die gelesene Besucherzahl wird dann um eins erhöht (für den momentanen Besucher). Danach wird die Dateilänge mit der Funktion ftruncate() auf 0 zurückgesetzt, d.h. der Inhalt der Datei wird gelöscht. Da wir aber zuvor die Besucherzahl aus der Datei gelesen haben, befindet sich der interne Dateizeiger am Ende der Datei. Diesen kann man mit der Funktion fseek() wieder an den Anfang der Datei bewegen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
127
Nachdem der Dateizeiger wieder am Anfang der Datei steht, kann in die Datei geschrieben werden, in diesem Fall die neue Besucherzahl ($count). Nach dem Schreibvorgang kann bzw. sollte die Sperrung der Datei gelöst werden. 7. Nachdem nun die Besucherzahl gelesen und aktualisiert wurde, kann bzw. sollte die Datendatei geschlossen werden. //~ Datei schließen fclose($filePointer); //~ Besucherzahl in Flash-Format ausgeben flash::echoVar("count", $count); ?> 8. Die neue Besucherzahl wird dann in Flash-kompatiblem Format ausgegeben und kann so von dem SWF weiterverarbeitet werden. Beispiel einer Ausgabe ist: &count=22& Dieser Besucherzähler ist noch sehr einfach. Ein Beispiel für eine etwas komplexere Einsatzmöglichkeit wäre z.B., an verschiedenen Stellen des SWF Angelpunkte mit Aufrufen dieses Scripts einzubauen und in verschiedenen Dateien zu speichern. So wäre es z.B. möglich zu erfassen, wie viele Besucher das Intro übersprungen oder wie viel Prozent der Gesamtbesucherzahl sich die Referenzen angesehen hat etc.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
128
Kapitel 5
5.6 Beispiel: automatische Sprachauswahl mit Hilfe von PHP Dieses Beispiel befindet sich im Ordner Applikationen\flashLanguage\ auf der CD-ROM. Inhalt des SWF:
Abbildung 5.4: Dieses SWF lädt den Willkommenstext, welcher im PHP-Script in der richtigen Sprache ermittelt wird und zeigt in in dem Textfeld text an.
Inhalt des PHP-Scripts:
= = = =
array("de", "at", "ch"); array("en", "us", "uk"); array("fr"); array("it");
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
129
//~ Willkommenstexte definieren $myTexts["de"] $myTexts["en"] $myTexts["fr"] $myTexts["it"]
= = = =
"Willkommen!"; "Welcome!"; "Bienvenue!"; "Benvenuto!";
//~ Standard für Willkommenstext $standardLanguage = "de"; //~ Sprache des Client (Browsers) auslesen $lang = getenv('HTTP_ACCEPT_LANGUAGE'); //~ Array erzeugen, da z.B. en,pdf $lang = split(",",$lang); //~ erstes Element wählen $userLanguage = $lang[0]; //~ Überprüfen, zu welcher Sprachgruppe die Sprache des Clients gehört while (list($key,$valueArray) = each($myLanguages)) { if (in_array($userLanguage, $valueArray)) { //~ Zugehörigkeit gefunden $standardLanguage = $key; } //~ end if } //~ end while //~ Willkommenstext korrekt formatiert ausgeben flash::echoVar("text", $myTexts[$standardLanguage], true); ?> Der Ablauf ist folgender: 1. Das SWF ruft das PHP-Script auf. 2. Das Script ermittelt anhand der Browsersprache die Sprache des Besuchers. 3. Wenn diese Sprache definiert wurde, wird der entsprechende (korrekt für Flash formatierte) Text ausgegeben, ansonsten der Text der Standardsprache. 4. Der zurückgegebene Text (in diesem Fall »Willkommen« in verschiedenen Sprachen) wird in einem Textfeld angezeigt.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
130
Kapitel 5
Aufbau der Applikation: 1. Erstellen Sie einen neuen Flash-Film mit zwei Ebenen. 2. Erstellen Sie auf der zweiten Ebene ein dynamisches Textfeld mit der Variable text. 3. Auf der ersten Ebene erstellen Sie eine (leere) Filmsequenz, die folgenden Code zugeordnet bekommt: onClipEvent (load) { loadVariables("flashLanguage.php", this); } onClipEvent (data) { _root.text = this.text; } Der erste onClipEvent() ruft das Script flashLanguage.php beim Start der Filmsequenz auf und lädt dessen Ausgabe in die Filmsequenz. Der zweite onClipEvent() gibt zeigt den zurückgegebenen Text in einem Textfeld auf Ebene 0 an, sobald er vollständig geladen wurde. · BEISPIEL
Ist die Sprache des Besuchers z.B. Englisch, dann ist die Ausgabe folgende: Welcome!
4. Das PHP-Script wird wie folgt erstellt: Zuerst muss die Klasse flash.inc.php eingebunden werden, um auf ihre Funktion zugreifen zu können. Dann muss noch dafür gesorgt werden, dass die Ausgabe des Scripts nicht im Cache des Browsers gespeichert und somit eventuell bei einem weiteren Besuch wiederholt angezeigt wird. Dies übernimmt der folgende Code:
= = = =
array("de", "at", "ch"); array("en", "us", "uk"); array("fr"); array("it");
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Umgang mit Flash und PHP
131
Der Schlüssel des Arrays ist die Sprache, die nachher ausgegeben wird. Für diese Schlüssel müssen in einem anderen Array Texte angegeben werden. Die Elemente des Arrays sind die verschiedenen Sprachen, die einer Gruppe zugeordnet werden. Dem deutschen Willkommenstext werden z.B. die deutsche, österreichische und schweizerische Sprachvariante des Deutschen zugeordnet. Es ist selbstverständlich auch möglich, für die Ausgabe einer Sprache nur eine einzige andere Sprache zu definieren, jedoch bietet sich die Zusammenfassung in Gruppen an. 6. Nun muss das Array festgelegt werden, das die verschiedenen Willkommenstexte enthält: //~ Willkommenstexte definieren $myTexts["de"] $myTexts["en"] $myTexts["fr"] $myTexts["it"]
= = = =
"Willkommen!"; "Welcome!"; "Bienvenue!"; "Benvenuto!";
Die Schlüssel des Arrays müssen hier mit den Schlüsseln identisch sein, die im vorigen Array definiert wurden. 7. Nun muss noch eine Standardsprache festgelegt werden: //~ Standard für Willkommenstext $standardLanguage = "de"; Die Standardsprache muss deshalb festgelegt werden, da es sein kann, dass der Browser einen Sprachcode übermittelt, der entweder in keiner der Gruppen definiert wurde oder unverständlich ist. Wenn die Sprache, die der Browser übermittelt, in einer der Gruppen gefunden wird, dann wird die Standardsprache durch diesen Code ersetzt. 8. Nun muss noch die Sprache des Browsers ausgelesen werden. Dies geschieht mit Hilfe der vom Browser automatisch übermittelten Variable $HTTP_ACCEPT_LANGUAGE. //~ Sprache des Clients (Browsers) auslesen $lang = getenv('HTTP_ACCEPT_LANGUAGE'); //~ Array erzeugen, da z.B. en,pdf $lang = split(",", $lang); //~ erstes Element wählen $userLanguage = $lang[0]; Da einige Browser (z.B. der Netscape 4.78) die HTTP_ACCEPT_LANGUAGE als kommasepariertes Array mit Zusatzinformationen übermitteln (z.B. en,pdf), müssen wir das erste Element (den Sprachcode) extrahieren.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
132
Kapitel 5
9. Nun muss überprüft werden, zu welcher Sprachgruppe die Sprache des Browsers gehört bzw. welcher Willkommenstext an den Benutzer ausgegeben werden soll: //~ Überprüfen, zu welcher Sprachgruppe die Sprache des Clients gehört while (list($key,$valueArray) = each($myLanguages)) { if (in_array($userLanguage, $valueArray)) { //~ Zugehörigkeit gefunden $standardLanguage = $key; } //~ end if } //~ end while Der oben stehende Code durchläuft das Array, in dem die Sprachgruppen definiert wurden. Findet er den Sprachcode des Browsers in einem der Arrays, so ersetzt er die Standardsprache (hier: Deutsch) durch den Schlüssel des Arrays, also durch den Wert für die Sprachgruppe. ·
BEISPIEL
Wenn die Variable $userLanguage den Wert uk enthält, dann wird dieser Wert in dem Array gefunden, das den Schlüssel en hat. Somit wird als Ausgabesprache Englisch festgelegt. Wenn die Variable $userLanguage den Wert cz enthält, dann wird dieser Wert in keiner der (hier) definierten Sprachgruppen gefunden und die Standardausgabesprache bleibt Deutsch.
10. Nachdem die Ausgabesprache ermittelt wurde, muss der entsprechende Text noch ausgegeben werden. Dies geschieht mit folgendem Code: //~ Willkommenstext korrekt formatiert und kodiert ausgeben flash::echoVar("text", $myTexts[$standardLanguage], true); ?> ·
HINWEIS
Die Browsersprache kann von der wirklichen Sprache des Benutzers abweichen. Einige Browser senden auch mehr als einen Sprachcode mit, in diesem Fall wird der Text der Standardsprache (hier: Deutsch) ausgegeben. Um hundertprozentig die Sprache zu wählen, die der Besucher versteht, sollten Sie ihn selbst wählen lassen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
KAPITEL 6
COOKIES MIT FLASH UND PHP
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
134
Kapitel 6
Cookie (engl.: Plätzchen, Keks) – Cookies (plural) sind Dateien, die von Anbietern im Internet auf der Festplatte des Besuchers gespeichert werden können. Sie enthalten z.B. Informationen über den letzten Besuch, die Anzahl der Besuche oder auch verschlüsselte Passwörter. Mit Flash allein lassen sich keine Cookies setzen und lesen, zusammen mit PHP jedoch lassen sich Cookies auch bei Flash-Projekten ohne weiteres einsetzen. Die Akzeptanz für Cookies ist nicht sehr groß, und sehr viele Surfer verweigern die Annahme von Cookies. An manchen Stellen jedoch sind Cookies besser als irgendeine andere Methode geeignet, um Daten von bestimmten Besuchern bzw. von jedem Besucher zu speichern, um später wieder darauf zugreifen zu können. Im folgenden Beispiel wird solch ein Einsatzgebiet gezeigt. Um das Beispiel nachvollziehen zu können, müssen Sie die Annahme von Cookies in Ihrem Browser aktiviert haben.
6.1 Beispiel: Cookies setzen / löschen Dieses Beispiel befindet sich im Ordner Applikationen\swfCookie\ auf der CD-ROM. Inhalt des PHP-Scripts:
Cookies mit Flash und PHP
135
if ($result) { //~ Cookie erfolgreich gesetzt $message = "Position gespeichert!"; } } else if ($action == "del") { //~ Cookie löschen $result = setcookie("c_Pos", "", time() - 3600); $message = "Cookie gelöscht!"; } //~ end if //~ Statusmeldung ausgeben flash::echoVar("message", $message, true); ?> Aufbau des SWF:
Abbildung 6.1: In diesem SWF befindet sich eine Filmsequenz (circle), die der Besucher mit der Maus verschieben kann. Beim Absetzen wird die Position der Filmsequenz in einem Cookie gespeichert. Bei wiederholtem Aufruf der Seite bzw. des SWF wird die Position der Filmsequenz wieder hergestellt.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
136
Kapitel 6
Der Ablauf ist folgender: 1. Im SWF befindet sich ein Kreis, der mit der Maus auf der Bühne verschoben werden kann. 2. Wird der Kreis an einer bestimmten Stelle abgesetzt, so werden die Positionsdaten (XWert und Y-Wert) an ein PHP-Script übermittelt. 3. Dieses PHP-Script speichert die gesetzte Position in einem Cookie mit einer Gültigkeitsdauer von einem Tag. 4. Wenn der Besucher nun innerhalb eines Tages auf die Seite mit diesem SWF zurückkehrt, dann werden mit PHP die Positionsdaten aus dem Cookie ausgelesen, in Flash geladen und der Kreis an die entsprechende Stelle gesetzt. Der Aufbau der Applikation: 1. Erstellen Sie einen neuen Flash-Film. 2. Erstellen Sie auf Ebene 0 ein neues dynamisches Textfeld mit dem Namen message. In diesem Textfeld werden nachher Statusmeldungen ausgegeben. 3. Erstellen Sie ebenfalls auf Ebene 0 eine neue Filmsequenz (hier: circle). In dieser Filmsequenz erstellen Sie eine neue Schaltfläche (hier: circleButton) mit beliebiger Form (hier: Kreis). Um die Filmsequenz verschiebbar zu machen und die Positionen in einem Cookie zu speichern, müssen Sie dieser Schaltfläche folgenden Code zuweisen: on (press) { _root.message = "Verschieben..."; this.startDrag(); } on (release) { _root.message = "Speichere aktuelle Position..."; this.stopDrag(); tStamp = new Date().getTime(); pos = "xPos="+_x+"&yPos="+_y; _root.loadVariables("swfCookie.php?action=set&"+pos+"&"+tStamp); } Bei der ersten Aktion für den Button wird die Filmsequenz bei einem Klick auf den Button an die Maus angeheftet und kann verschoben werden. Wird die Maus losgelassen, so wird der Code in on (release) ausgeführt. Er entfernt die Filmsequenz von der Maus.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Cookies mit Flash und PHP
137
In der dritten Zeile wird ein Timestamp erstellt, das ist deshalb wichtig, da das PHPScript nicht aus dem Cache geladen werden darf. In der vierten Zeile wird die Position der Filmsequenz in einen String umgeformt, der dann an das PHP-Script übergeben wird. Die Aktion »Cookie setzen« (action=set) und der Timestamp werden zusätzlich noch an den URL angehängt. Die Aktion teilt dem PHP-Script mit, die Positionsdaten zu verarbeiten und in einem Cookie zu speichern. 4. Nun wird noch der Code benötigt, um die Filmsequenz an eine bestimmte (im Cookie gespeicherte) Position zu verschieben. Dazu weisen Sie der Filmsequenz folgenden Code zu: onClipEvent (load) { this.loadVariables("swfCookie.php"); } onClipEvent (data) { this._x = this.xPos; this._y = this.yPos; _root.message = this.message; } Der erste Event lädt die im Cookie gespeicherte Position in die Filmsequenz (das PHPScript extrahiert die Position aus dem Cookie und gibt sie dann für Flash lesbar aus). Der zweite Event bewegt die Filmsequenz an die entsprechende Position (wenn eine gespeichert wurde), sobald alle Daten geladen sind. 5. Erstellen Sie nun eine weitere Schaltfläche (hier: button) auf Ebene 0 und weisen Sie dieser folgenden Code zu: on (release) { message = "Cookie wird gelöscht..."; loadVariablesNum("swfCookie.php?action=del", 0); } Bei einem Klick auf diese Schaltfläche wird das PHP-Script mit der Aktion »Löschen« aufgerufen (action=del). Das PHP-Script löscht dann das gespeicherte Cookie. Beim nächsten Aufruf der Seite mit dem SWF wird die Filmsequenz dann nicht bewegt, da keine Positionsdaten gespeichert wurden. 6. Der Flash-Teil dieser Applikation ist nun beendet. Der Inhalt des PHP-Scripts ist folgender:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
138
Kapitel 6
Cookies mit Flash und PHP
139
Zuerst wird überprüft, ob das Cookie bereits gesetzt wurde. Die Variable im Cookie, in der die Position gespeichert wird, ist $c_Pos. Wenn $c_Pos definiert ist, dann ist das Cookie bereits gesetzt worden. Die Variable $c_Pos hat folgende Form: x-Wert|y-Wert Das bedeutet: Wenn die Filmsequenz auf die Position _x = 100 und _y = 50 gezogen wurde, enthält die Variable $c_Pos folgenden Wert: 100|50 Um aus diesem Wert wieder die X-Position und die Y-Position zu bekommen, muss an dem |-Zeichen gesplittet werden. Zurückgegeben wird ein Array, das als erstes Element den X-Wert und als zweites Element den Y-Wert enthält. Diese Werte werden dann ausgegeben. Mit den Beispielwerten von oben wird die Ausgabe so aussehen: &xPos=302.25& &yPos=139.25& Wenn das Cookie noch nicht gesetzt wurde, werden keine Positionswerte zurückgegeben. An verschiedenen Stellen werden Statusmeldungen definiert, diese werden ganz am Ende des Scripts ausgegeben. Sie werden hier nicht näher beschrieben, da sie für die Funktionalität der Applikation nicht weiter wichtig sind. 9. Nun wenden wir uns dem Teil des PHP-Scripts zu, in welchem das Cookie gesetzt bzw. die Position der Filmsequenz gespeichert wird. Fügen Sie nach } else if ($action == "set") { folgenden Code ein: //~ Positionen in Cookie speichern; Gültigkeit: 24h $result = setcookie("c_Pos", $xPos."|".$yPos, time()+3600*24); if ($result) { //~ Cookie erfolgreich gesetzt $message = "Position gespeichert!"; } else { //~ Fehlschlag beim Setzen des Cookies $message = "Fehler beim Speichern!"; } //~ end if DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
140
Kapitel 6
Von dem SWF werden drei Informationen übergeben, einmal die Aktion (action=set), die dazu führt, dass der oben stehende Code ausgeführt wird, und dazu der X-Positionswert ($xPos) der Filmsequenz und der Y-Positionswert ($yPos) der Filmsequenz. Die Positionswerte werden mit der Funktion setcookie() in einem Cookie in der Form X-Wert|Y-Wert gespeichert. Die Gültigkeit des Cookies beträgt genau 24 Stunden. Nach 24 Stunden ist das Cookie ungültig und kann nicht mehr verwendet werden bzw. es wird vom Rechner des Clients entfernt. Sie können die Gültigkeitsdauer selbstverständlich verlängern, jedoch sollte in unserem Fall eine Zeit von 24 Stunden ausreichend sein. Die Angabe der Gültigkeit muss in Sekunden erfolgen (3600[Sekunden pro Stunde]*24[Stunden]). Die Variable, die gespeichert wird, und unter der nachher auch die Positionswerte zu finden sind, ist in diesem Fall $c_Pos. Sie können diese Variable nennen, wie es Ihnen beliebt, allerdings sollten Sie darauf achten, dass Sie der Variable erstens einen eindeutigen und einmaligen Namen geben, und dass Sie die Variable zweitens kennzeichnen bzw. nachher erkennen können, dass dies eine Variable aus einem Cookie ist. Hier geschieht das durch das Voranstellen von c_. Sollten Sie eine Variable im Cookie speichern bzw. einen Namen für die Variable benutzen, welchen Sie auch im PHP-Script verwenden, so kann es dazu kommen, dass diese Variable versehentlich überschrieben wird. Achten Sie also darauf, dass Sie einen eindeutigen und einmaligen Namen vergeben. Bei sensiblen Daten ist es zudem noch sinnvoll, die Variablennamen nicht so zu wählen, dass jeder, der in das Cookie hineinsieht, sofort erkennt, für was die Variable verwendet wird. Wenn Sie ein Cookie speichern, das die Login-Informationen z.B. eines Forums enthält, so nennen Sie die Variable nicht master_password sondern besser: mpw oder geben Sie ihr einen anderen Namen, der nicht sofort auf den Inhalt schließen lässt. Wenn Sie Passwörter in Cookies speichern, dürfen Sie diese selbstverständlich keinesfalls unverschlüsselt speichern. Eine übliche Vorgehensweise ist, nur die Prüfsumme eines Passworts und den Primärschlüssel des Benutzers in der Datenbank im Cookie zu speichern. Andernfalls würde das Passwort nämlich immer im Klartext per HTTP verschickt werden, was eine große Sicherheitslücke darstellt.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Cookies mit Flash und PHP
141
Die Funktion setcookie() int setcookie (string name [, string value [, int expire [, string path [, string domain [, int secure]]]]]) Tutorial
Mit dieser Funktion lassen sich Cookies senden bzw. setzen. Zurückgegeben wird ein entweder true (wahr) bei Erfolg der Funktion oder false (falsch) bei einem Fehlschlag. Alle Parameter bis auf name sind optional. Wenn Sie nur das Argument name angeben, wird das Cookie gelöscht. Parameter: string name Der Name des Cookies und gleichzeitig auch der Name der Variable, die nachher in PHP verfügbar ist. Sie sollten im Namen keine Sonderzeichen verwenden, sondern nur Zeichen, die auch in PHP bei Variablennamen verwendet werden dürfen. Der Variablenname ist case-sensitive, d.h. es wird zwischen Groß- und Kleinschreibung unterschieden. Beispiel: Wenn Sie ein Cookie mit folgendem Code setzen: Dann können Sie in PHP (vorausgesetzt, register_globals in der php.ini wurde auf on gesetzt) durch $c_test $HTTP_COOKIE_VARS["c_test"] auf den Inhalt der Variable zugreifen. string value Dieses Argument bezeichnet den Wert des Cookies. Der Wert wird automatisch URL-kodiert und beim Laden des Cookies wieder dekodiert. Wenn Sie das Cookie löschen wollen, so lassen Sie dieses Argument aus bzw. verwenden "", um es zu übergehen. int expire Dieses Argument ist das Verfallsdatum des Cookies. Es muss in Sekunden seit dem 1. Januar 1970 angegeben werden. Die Sekunden seit dem 1. Januar 1970 können mit der Funktion time() ermittelt werden. Beispiel: Um ein Cookie mit 24 Stunden Gültigkeit zu erstellen, muss man folgenden Code benutzen:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
142
Kapitel 6
Tutorial
Sek. seit dem 1. Jan. 1970 plus 3600 (Sekunden pro Stunde) mal 24 (Stunden pro Tag) */ $expire = time() + 3600 * 24; setcookie("c_test", "Hallo", $expire); ?> Um dieses Argument zu übergehen, setzen Sie es einfach gleich 0 string path Mit diesem Parameter kann man den Pfad bestimmen, in dem das Cookie gültig ist. Beispiel: Dieses Cookie ist nun im Verzeichnis /test und allen Unterverzeichnissen gültig. In einem übergeordneten Verzeichnis lässt sich nicht auf den Inhalt des Cookies zugreifen. Um dieses Argument zu übergehen, setzen Sie es einfach gleich "". string domain Mit diesem Parameter kann man die Domain bestimmen, auf der das Cookie gültig ist. Beispiel: Dieses Cookie ist nur auf der Domain flashtool.de gültig. Um dieses Argument zu übergehen, setzen Sie es einfach gleich "". int secure Mit diesem Parameter kann festgelegt werden, ob die Daten des Cookies nur bei einer gesicherten Verbindung (HTTPS; siehe Kapitel 5.2) übertragen werden dürfen. Beispiel: Dieses Cookie bzw. dessen Daten würde(n) nur bei einer gesicherten Verbindung übertragen werden bzw. verfügbar sein. Um dieses Argument zu übergehen bzw. eine Übertragung immer zuzulassen, setzen Sie es einfach gleich 0. · HINWEIS
Cookies können konstruktionsbedingt erst bei der nächsten HTTP-Anforderung ausgelesen werden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Cookies mit Flash und PHP
Tutorial
143
Beispiel: Man könnte annehmen, dass dieses Script Hallo ausgibt, dies ist aber nicht richtig. Cookies werden nur bei Beginn des Aufrufs eines Scripts geladen. In diesem Fall ist das Cookie (und damit die Variable $c_test) zum Zeitpunkt der Ausgabe noch nicht verfügbar. Wenn Sie das oben stehende Script im Browser aktualisieren, ist das Cookie verfügbar und es wird Hallo ausgegeben. Wenn Sie eine Variable sowohl in einem Cookie speichern als auch sofort darauf zugreifen wollen, dann empfiehlt sich folgender Code: In diesem Fall würde die Ausgabe sofort funktionieren. Mit der if-Abfrage wird sichergestellt, dass die Variable bei erneutem Laden bzw. Aktualisieren nicht überschrieben wird. Cookies müssen mit denselben Parametern gelöscht werden, mit denen sie gesetzt wurden. Beispiel: Der folgende Code
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
144
Kapitel 6
müsste so gelöscht werden:
Tutorial
10. Dann benötigen wir den Teil des Scripts, in dem das Cookie gelöscht wird. Fügen Sie nach } else if ($action == "del") { folgenden Code ein: //~ Cookie löschen setcookie("c_Pos", "",time() - 3600); //~ Cookie erfolgreich gelöscht $message = "Cookie gelöscht!"; } Mit diesem Code wird das Cookie gelöscht. Die Funktion setcookie() wird mit leerem value-Parameter aufgerufen. Der Wert, der dem expire-Parameter übergeben wird, bezeichnet ein Datum bzw. eine Sekundenzahl seit dem 1. Januar 1970 in der Vergangenheit. 11. Im gesamten Script wurden an verschiedenen Stellen Statusmeldungen definiert ($message). Diese Statusmeldung wird nun ausgegeben. Und zwar mit folgendem Code: //~ Statusmeldung ausgeben flash::echoVar("message", $message, true); Dieser Code gibt eine Statusmeldung in der Form &message=kodierte+Statusmeldung& aus, die von Flash in einem Textfeld angezeigt wird. Diese Statusmeldung ist für die Funktionstüchtigkeit nicht relevant, erleichtert aber das Verständnis dieses Beispiels.
6.2 Wichtiges bei Verwendung von Cookies Sehr viele Personen, besonders diejenigen, die oft und viel im Internet zu tun haben, könnten die Annahme von Cookies verweigern. Wenn Sie Cookies verwenden, so sollten Sie diese nur an Stellen einsetzen, wo sie zusätzlichen Nutzen bringen. Ein Onlineshop, der verlangt, dass der Besucher Cookies annimmt, schreckt ab. Programmieren Sie deshalb Ihre Seiten immer so, dass die volle Funktionalität auch ohne Cookies gegeben ist. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Cookies mit Flash und PHP
145
Mehr Informationen zu Cookies finden Sie unter: www.netscape.com/newsref/std/cookie_spec.html ·
HINWEIS
Microsofts Internet-Explorer 4 mit Service-Pack 1 geht nicht korrekt mit Cookies um, die den Pfad-Parameter beinhalten. Netscape Communicator 4.05 und Microsoft Internet Explorer 3.x scheinen mit Cookies Probleme zu haben, wenn die Argumente für Pfad und Zeit nicht angegeben sind. (Quelle: : www.php.net)
6.3 Sicherheitsaspekte Speichern Sie niemals jegliche Art von sensiblen Daten (Passwörter, persönliche Daten des Benutzers etc.) in Cookies. Cookies liegen auf dem Rechner des Client in Form von Dateien vor und können mit einem einfachen Texteditor geöffnet und gelesen werden. Sollten Sie dennoch Passwörter etc. in Cookies speichern, so sollten Sie diese verschlüsseln – Passwörter z.B. mit der md5()Funktion von PHP. Sollten Sie es nicht vermeiden können, sensible Daten in Cookies zu speichern, so verwenden Sie beim Übermitteln der Cookie-Daten unbedingt eine sichere Verbindung. Nur so kann sichergestellt werden, dass die Daten auf direktem Weg zum Server gelangen und nicht von Dritten manipuliert oder abgefangen werden können.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
KAPITEL 7
XML MIT FLASH UND PHP
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
148
Kapitel 7
XML – (engl. eXtensible Markup Language = »erweiterbare Auszeichnungssprache«) XML wird verwendet, um komplexe Datenstrukturen auf Textbasis darzustellen. Der vom W3C festgelegte Standard wird von Flash seit Version 5 verstanden. Mit XML wird in Flash ein weiteres Verfahren geboten, Daten mit anderen Applikationen auszutauschen. Um komplexe Datenstrukturen darzustellen, ist XML besser geeignet als die herkömmliche Weise über Variablen (&variable1=wert&variable2=wert), jedoch ist in Flash 5 der XML-Parser noch sehr langsam und unbeholfen. Bei Datenmengen um ca. 60 Kbyte geht er teilweise vollständig in die Knie. Zudem kommt noch hinzu, dass das Laden von XML-Daten wesentlich länger dauert als das Laden von herkömmlichen Variablen. Die Zeitdifferenz kann bei großen Datenmengen eventuell schon bei einigen Sekunden liegen, was XML für zeitkritische Dinge unbrauchbar macht. Dennoch möchte ich an dieser Stelle auf den Umgang mit XML eingehen, da in PHP seit Version 4.0 standardmäßig Funktionen für den Umgang mit XML vorhanden sind (Beta in den PHP-Versionen von 3.0.8 bis 3.0.18). Auf diese Funktionen werde ich im Rahmen dieses Buches nicht eingehen, jedoch auf den Austausch von Daten in XML zwischen Flash und PHP.
7.1 Ein- und Ausgabe von Daten In diesem Unterkapitel werde ich auf die Ein- und Ausgabe von Daten mit Hilfe der XMLFunktionen von Flash und der Funktionen von PHP eingehen.
7.1.1 Funktionen Die folgenden Funktionen gibt es in Flash (ab Version 5) standardmäßig. Mit Ihnen lassen sich XML-Daten erstellen, bearbeiten, laden und senden. XML.load() Beschreibung: Mit dieser Funktion können Daten von einem angegebenen URL in ein XML-Objekt geladen werden. Die Funktion läuft asynchron ab. Bereits im XML-Objekt vorhandene Daten werden verworfen. Definition:
XMLObject.load (string url)
Parameter:
string url Ein relativer oder absoluter URL. Der URL kann eine XML-Datei oder ein (PHP-)Script sein, das XML-Daten ausgibt. Der angegebene URL muss sich
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
XML mit Flash und PHP
149
unterhalb der Domain befinden, auf der sich das SWF befindet; Zugriff auf externe URLs ist nicht möglich (siehe auch Kapitel 5.1). Anwendung:
//~ ActionScript myXML = new XML(); myXML.load("meinScript.php"); /*~ Das XML-Objekt myXML enthält nach dem Ladevorgang die Daten, die das PHP-Script ausgegeben hat. */ ·
HINWEIS
Diese Funktion ist asynchron, d.h. die Daten stehen eventuell nicht sofort nach dem Aufruf von load() zur Verfügung. Um zu überprüfen, ob der Ladevorgang bereits beendet wurde, können die Funktion onLoad() und die Eigenschaft loaded verwendet werden (siehe unten).
XML.send() Beschreibung: Mit dieser Funktion kann ein XML-Objekt aus Flash per POST an einen URL gesendet werden. Das XML-Objekt wird automatisch kodiert. Definition:
XMLObject.send (string url [, string target])
Parameter:
string url Ein relativer oder absoluter URL. string target Dieses Argument ist optional. Dieses Argument bezeichnet das Browserfenster, in dem der URL geöffnet wird. Dies kann sowohl ein bereits bestehendes als auch ein neues Browserfenster sein.
Anwendung:
//~ ActionScript myXML = new XML(); XMLElement = myXML.createElement("Child"); XMLElement.attributes.age = "10"; myXML.appendChild(XMLElement); myXML.docTypeDecl = "myXML="; myXML.send("meinScript.php", "_blank"); Dieser Code öffnet das Script meinScript.php in einem neuen Browserfenster und übergibt ein XML-Objekt bzw. XML-Daten in der folgenden Form: DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
150
Kapitel 7
·
HINWEIS
Da das XML-Objekt Anführungszeichen enthält, müssen vor der Bearbeitung der XML-Daten in PHP zuerst die hinzugefügten \ (Backslashes) entfernt werden. Dies geschieht mit der Funktion stripslashes().
Beispiel: Im oberen Script ist der Variablenname des gesendeten XML-Objekts $myXML. Um die Backslashes zu entfernen, muss der Aufruf also so lauten: XML.sendAndLoad() Beschreibung: Diese Funktion übergibt die Daten eines XML-Objekts mittels POST an ein PHP-Script und empfängt dessen Ausgabe in einem anderen XML-Objekt. Das XML-Objekt wird automatisch kodiert. Definition:
XMLObject.sendAndLoad (string url, object targetXMLObject)
Parameter:
string url Ein relativer oder absoluter URL zu einem (PHP-)Script, das XML-Daten zurückgibt. Der angegebene URL muss sich unterhalb der Domain befinden, auf der sich das SWF befindet; Zugriff auf externe URLs ist nicht möglich (siehe auch Kapitel 5.1). object targetXMLObject Ein in Flash vorher definiertes XML-Objekt. Wenn dieses Objekt bereits Daten enthält, werden diese durch die geladenen Daten überschrieben.
Anwendung:
//~ ActionScript myXML = new XML(); targetXML = new XML(); XMLElement = myXML.createElement("Child"); XMLElement.attributes.age = "10"; myXML.appendChild(XMLElement); myXML.docTypeDecl = "myXML="; myXML.sendAndLoad("meinScript.php", targetXML); Dieser Code sendet das XML-Objekt myXML an das Script meinScript.php und empfängt dessen Ausgabe im XML-Objekt targetXML. ·
HINWEIS
Beachten Sie, dass zusätzliche Backslashes hinzugefügt wurden, um vorhandene Anführungszeichen zu escapen. Wie Sie diese entfernen, erfahren Sie bei der Anwendung des Befehls send() in diesem Abschnitt (siehe oben).
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
XML mit Flash und PHP
151
7.1.2 Events XML.onLoad() Beschreibung: Diese Funktion wird automatisch aufgerufen, sobald ein XML-Dokument bzw. XML-Daten empfangen wurden. Diese Funktion kann mit einer eigenen Funktion überschrieben werden (siehe unten). Definition:
XMLobject.onLoad (bool success)
Parameter:
bool success Dieser Parameter gibt an, ob der Ladevorgang erfolgreich abgeschlossen wurde oder nicht. Wenn ja, dann ist dieser Wert true (wahr), wenn ein Fehler auftrat, dann ist er false (falsch).
Anwendung:
//~ ActionScript myXML = new XML(); myXML.load("meinScript.php"); myXML.onLoad = fertig; function fertig (success) { if (success) { trace("Korrekt geladen."); } else { trace("Es trat ein Fehler auf!"); } //~ end if } //~ end func Der obere Code lädt die Ausgabe des Scripts meinScript.php. Wenn der Ladevorgang erfolgreich abgeschlossen wurde, wird Korrekt geladen. auf dem Bildschirm ausgegeben, andernfalls: Es trat ein Fehler auf!
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
152
Kapitel 7
7.1.3 Eigenschaften XML.loaded Beschreibung: Diese Eigenschaft zeigt an, ob ein Ladevorgang erfolgreich beendet wurde oder nicht. Bei erfolgtem Laden enthält sie den Wert true (wahr), während des Ladevorgangs oder bei einem Fehler den Wert false (falsch). Diese Eigenschaft kann nicht manuell verändert werden. Definition:
XMLObject.loaded = true|false true|false bedeutet hier, dass die Eigenschaft einen dieser beiden Werte annehmen kann, also kann sie entweder true (wahr) sein oder false (falsch).
Parameter:
Keine. Eigenschaft.
Anwendung:
//~ ActionScript myXML = new XML(); if (myXML.loaded == undefined) { trace ("undefined"); } myXML.load("meinScript.php"); trace(myXML.loaded); //~ gibt false zurück myXML.onLoad = function () { trace(myXML.loaded); //~ gibt true zurück } //~ end func Hier wird die loaded-Eigenschaft dreimal abgefragt, einmal vor dem Ladevorgang, einmal direkt nach dem Aufruf von load() und einmal, nachdem die Daten geladen wurden. Es wird Folgendes auf dem Bildschirm ausgegeben: undefined false true Daraus ergibt sich Folgendes: · Wenn noch keine Daten in das XML-Objekt geladen wurden, ist die
Eigenschaft undefiniert.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
XML mit Flash und PHP
153
· Wenn die Daten gerade geladen werden, ist die Eigenschaft definiert und
false (falsch). · Wenn die Daten komplett geladen wurden, ist die Eigenschaft definiert
und true (wahr). XML.docTypeDecl Beschreibung: Mit dieser Funktion kann man die DOCTYPE-Deklaration (DTD) des XMLObjekts definieren bzw. verändern. Normalerweise wird die DTD dazu verwendet, die Gültigkeit und Struktur der Daten zu beschreiben. Hier jedoch wird sie benötigt, damit PHP bzw. ein PHP-Script ein übergebenes XMLObjekt überhaupt als Variable erkennt, deshalb auch das Gleichheitszeichen. Definition:
XMLObject.docTypeDecl = string DTD
Parameter:
Keine. Eigenschaft.
Anwendung:
//~ ActionScript myXML = new XML(); myXML.docTypeDecl = "myXML="; XMLElement = myXML.createElement("Child"); XMLElement.attributes.age = "10"; myXML.appendChild(XMLElement); myXML.send("meinScript.php", "_blank"); In diesem Fall heißt die Variable innerhalb des PHP-Scripts meinScript.php, die die Daten des XML-Objekts myXML enthält, $myXML. ·
HINWEIS
Beachten Sie, dass zusätzliche Backslashes hinzugefügt wurden, um vorhandene Anführungszeichen zu escapen. Wie Sie diese entfernen, erfahren Sie bei der Anwendung des Befehls send() in diesem Abschnitt (siehe oben).
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
154
Kapitel 7
7.2 Beispiel: Daten von PHP nach Flash übergeben Dieses Beispiel befindet sich im Ordner Beispiele\XML\phpXML\ auf der CD-ROM. Aufbau des SWF:
Abbildung 7.1: Dieses SWF lädt XML-Daten von einem PHP-Script, speichert diese in einem XML-Objekt und gibt sie in anderem Format in einem Textfeld wieder aus.
Der XMLNode-Prototyp print(): XMLNode.prototype.print = function (level) { var string; for (var i = 0; i < this.childNodes.length; i++) { //~ Tabs je nach Level hinzufügen for (var o = 0; o < level; o++) { string += "\t"; } //~ Knotenname und Attribute hinzufügen string += this.childNodes[i].aText(); if (this.childNodes[i].hasChildNodes()) {
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
XML mit Flash und PHP
155
//~ Hat untergeordnete Knoten //~ level um eins erhöhen level++; //~ Funktion mit untergeordnetem Knoten starten string += this.childNodes[i].print(level); } //~ end if } //~ end for //~ String zurückgeben return string; } //~ end function print Der XMLNode-Prototyp aText(): XMLNode.prototype.aText = function () { var string; //~ Name des Knotens hinzufügen string += this.nodeName; //~ Attribute in Array speichern array = this.attributes; //~ Array mit Attributen durchlaufen for (var key in array) { //~ Attribute hinzufügen string += " | "+key+" = "+array[key]; } //~ end for //~Zeilenumbruch hinzufügen string += "\n"; //~ String zurückgeben return string; } //~ end function aText
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
156
Kapitel 7
Aufbau des PHP-Scripts: "; //~ Ausgabe der XML-Daten echo ""; while (list($key,$valueArray) = each($fruitArray)) { $n = $valueArray["name"]; $f = $valueArray["farbe"]; echo " "; } //~ end while echo " "; ?> Der Ablauf ist folgender: 1. Ein Array in PHP wird als XML mit bestimmter Struktur ausgegeben. 2. Das SWF lädt diese XML-Struktur, extrahiert ihre Elemente und gibt diese mit Hilfe einer Funktion in anderer Form in einem Textfeld aus.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
XML mit Flash und PHP
157
Der Aufbau der Applikation: 1. Erstellen Sie einen neuen Flash-Film. 2. Erstellen Sie ein dynamisches Textfeld auf Ebene 0 mit dem Namen text. Dieses Textfeld wird benötigt, um später die geladenen Daten auszugeben. 3. Fügen Sie nun im ersten Bild die zwei oben stehenden Prototypen (XMLNode.print() und XMLNode.aText()) ein. Diese werden benötigt, um die XML-Struktur umzuformen und im Textfeld auszugeben. Ich werde nicht näher auf die Prototypen eingehen, da sie mit Hilfe des Flash-Manuals und der beigefügten Kommentare ohne weiteres verstanden werden können. 4. Anschließend müssen Sie zusätzlich zu den Prototypen im ersten Bild noch folgenden Code einfügen: //~ Neues XML-Objekt erstellen myXML = new XML(); //~ XML-Dokument laden myXML.load("phpXML.php"); //~ Überprüfen, ob XML-Dokument geladen wurde myXML.onLoad = function () { //~ XML-Dokument wurde vollständig geladen if(!myXML.loaded) { text = "Es trat ein Fehler auf!"; } else { //~ XML-Dokument umstrukturiert in Textfeld ausgeben text = myXML.print(); } } Zuerst wird ein neues XML-Objekt erstellt, das nachher unsere Daten aus dem PHPScript bzw. aus dessen Ausgabe enthalten soll. Dann wird mit der XML-Funktion load() die Ausgabe des PHP-Scripts (hier: phpXML .php) in das XML-Objekt geladen. Sobald die XML-Daten vollständig geladen wurden, wird der Code, der in den Klammern der XML-Funktion onload() steht, ausgeführt. Dort wird überprüft, ob beim Laden ein Fehler aufgetreten ist. Wenn ja, wird eine Meldung in dem erstellten Textfeld ausgegeben. Wenn nein, dann wird das Parsen des XML-Objekts gestartet und die Ausgabe im Textfeld angezeigt. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
158
Kapitel 7
5. Wenden wir uns nun dem PHP-Script zu, das die XML-Daten ausgibt. 6. Zuerst muss ein Array definiert werden. Etwa so: "; //~ Ausgabe der XML-Daten echo ""; while (list($key,$valueArray) = each($fruitArray)) { $n = $valueArray["name"]; $f = $valueArray["farbe"]; echo " "; } //~ end while echo " "; ?> Zuerst wird mit der Header-Funktion dem Browser mitgeteilt, dass es sich bei den ausgegebenen Daten um XML-Daten handelt. Geben wir die Daten ohne diese Information aus, würden sie als HTML dargestellt. Mit dieser Information zeigt ein XML-kompatibler Browser (z.B. Internet Explorer) das XML-Dokument auch als solches an. DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
XML mit Flash und PHP
159
Nachdem der Header gesendet wurde, wird das Array $fruitArray durchlaufen und die Daten werden korrekt formatiert direkt an den Bildschirm ausgegeben. Wichtig ist, dass alle Daten URL-kodiert werden. XML erlaubt nur alphanumerische Zeichen und (.-_). Die Form der Ausgabe ist folgende: <Parent numofChildren="2"> In unserem konkreten Fall ist die Ausgabe dann diese: Diese Ausgabe wird von Flash geladen und dann in ein anderes Format gebracht. Selbstverständlich können Sie noch mehr Ebenen hinzufügen als nur eine. Die Ausgabe im Textfeld nach dem Parsen sieht in diesem Fall so aus: Fruechte | Frucht Frucht Frucht Frucht Frucht
Size = | Name | Name | Name | Name | Name
5 = = = = =
Zitrone | Farbe = gelb Erdbeere | Farbe = rot Heidelbeere | Farbe = blau Granny-Smith | Farbe = grün Orange | Farbe = orange
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
160
Kapitel 7
7.3 Beispiel: Daten von Flash nach PHP übergeben Dieses Beispiel befindet sich im Ordner Beispiele\XML\flashXML\ auf der CD-ROM. Aufbau des SWF:
Abbildung 7.2: In diesem SWF wird ein XML-Objekt erstellt, das auf Knopfdruck per POST als XML-Dokument an ein PHP-Script übergeben wird.
Aufbau des PHP-Scripts:
XML mit Flash und PHP
161
//~ XML-Dokument ausgeben echo $myXML; ?> Der Ablauf ist folgender: 1. In Flash bzw. dem SWF wird ein XML-Objekt erstellt. 2. Dieses XML-Objekt wird als XML-Dokument mittels POST an das PHP-Script übergeben. 3. Das PHP-Script gibt das XML-Dokument im Browser aus. Der Aufbau der Applikation: 1. Erstellen Sie einen neuen Flash-Film. 2. Erstellen Sie ein neues XML-Objekt mit folgendem Code: //~ ActionScript //~ Neues XML-Objekt erstellen myXML = new XML(); //~ DOCTYPE-Deklaration definieren myXML.docTypeDecl = "myXML="; /*~ Nun können weitere Knoten erstellt und an das XML-Objekt angeheftet werden */ Erstellen Sie danach beliebig viele Knoten, wie z.B. in unserem Beispiel (siehe oben). Wie die Struktur des XML-Dokuments aussieht, ist im Moment nicht von Bedeutung, wichtig für uns ist die DOCTYPE-Deklaration. Die DOCTYPE-Deklaration legt fest, mit welchem Variablennamen das XML-Dokument nachher in PHP angesprochen werden kann. Wenn Sie diese Definition nicht machen, kann das XML-Dokument innerhalb von PHP nicht angesprochen werden. ·
Wenn die Deklaration folgendermaßen aussieht: //~ ActionScript XMLObjekt.docTypeDecl = "XML=";
BEISPIEL
·
HINWEIS
kann man nach dem Senden des XML-Objekts an das PHP-Script mit $XML auf das Objekt zugreifen. Sie dürfen nur Zeichen verwenden, die ein Variablenname in PHP enthalten darf. Ein gültiger Variablenname in PHP beginnt mit einem Dollarzeichen ($), gefolgt von einem Buchstaben oder Unterstrich. Hinter diesem können beliebig viele Buchstaben, Zahlen oder Unterstriche in beliebiger Kombination folgen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
162
Kapitel 7
3. Erstellen Sie nun auf Ebene 0 eine Schaltfläche und weisen Sie ihr folgenden Code zu: //~ ActionScript on (release) { myXML.send("flashXML.php", "_self"); } Dieser Code sendet das XML-Objekt bei Klick auf die Schaltfläche per POST an das PHPScript flashXML.php und öffnet es im selben Browserfenster. 4. Nun wenden wir uns dem PHP-Script zu. Das PHP-Script soll das XML-Objekt bzw. die XML-Daten auf dem Bildschirm ausgeben. Dazu benötigen wir folgenden Code: Zuerst muss eine entsprechende Kopfzeile gesendet werden, d.h. dem Browser muss mitgeteilt werden, dass XML-Daten ausgegeben werden. Dies macht die header()Funktion. Da im XML-Objekt Anführungszeichen vorhanden sind, wurden diese mit einem \ (Slash) deaktiviert (escaped). Dies muss man rückgängig machen, indem man die Slashes mit der Funktion stripslashes() aus dem String entfernt. Danach werden die XML-Daten an den Browser ausgegeben. In unserem Fall (mit dem XML-Objekt aus dem Beispiel) würde das so aussehen: <Software> Es kann sein, dass in Ihrem Browser nichts angezeigt wird. Das liegt dann daran, dass der Browser kein XML versteht. Wenn Sie aber in den Quelltext schauen, können Sie zumindest die Struktur erkennen, die Sie zuvor in Flash definiert haben. · HINWEIS
An dieser Stelle könnte man (anstatt die XML-Daten nur auszugeben) auch mit den XML-Funktionen von PHP auf diese Daten zugreifen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
KAPITEL 8
SERVERSEITIGE ERZEUGUNG VON FLASH-INHALTEN
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
164
Kapitel 8
In diesem Kapitel wird die serverseitige Erzeugung von Flash-Inhalten bzw. SWFs angesprochen. Es werden verschiedene Möglichkeiten gezeigt, von der reinen Neuerstellung des SWF bis hin zur Manipulation von vorgefertigten Templates.
8.1 ... mit Ming und PHP Ming ist eine Bibliothek, mit der man SWF-Files erstellen kann. Eigentlich ist Ming eine C-Bibliothek, allerdings wurden einige Wrapper für populäre Sprachen geschrieben, so auch für PHP. Die aktuelle Version des Moduls für PHP ist Version 0.2a. Mit dieser Version wurden die Beispiele erstellt und getestet. Die Ming-Bibliothek (für Windows und Linux) und andere Tools befinden sich im Ordner Software und Module\Ming\ auf der CD-ROM. Mehr Informationen finden Sie unter: www.opaque.net/ming/
8.1.1 Einbindung des Ming-Moduls Damit man auf die Ming-Funktionen zugreifen kann, muss vorher die Ming-Bibliothek geladen werden. Es ist möglich, dass das Ming-Modul bereits auf manchen Servern global verfügbar ist und ohne Einbinden verwendet werden kann. Dies erfahren Sie bei Ihrem ISP bzw. dessen Administrator. Die Mehrzahl der ISPs wird jedoch das Ming-Modul nicht auf ihren Servern installiert haben, deshalb muss es von Hand dynamisch eingebunden werden. Dies geht mit folgendem Code: Die dl()-Funktion lädt das Ming-Modul dynamisch. Eventuell kann auch das dynamische Laden von Modulen (in diesem Fall das Ming-Modul) fehlschlagen, wenn in der php.ini der Schalter enable_dl auf off gestellt ist. Ob dies der Fall ist, können Sie entweder bei Ihrem ISP bzw. dessen Administrator erfahren oder einfach durch Ausprobieren feststellen. Die Bibliothek wird in diesem Fall eine Fehlermeldung generieren und die Ausführung des Scripts abbrechen.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Serverseitige Erzeugung von Flash-Inhalten
165
Wichtig ist, dass das Einbinden vor dem Zugriff auf die Funktionen des Moduls geschieht. Wird das Modul danach erst eingebunden, sind zum Zeitpunkt der Ausführung die Funktionen noch nicht verfügbar. · HINWEIS
Bibliotheken haben für Linux normalerweise die Endung .so auf NT-Servern bzw. Windows-Rechnern die Endung .dll. Beide Module finden Sie auf der CD-ROM.
Die Funktion dl() int dl (string library) Das Argument für die Funktion ist der Dateiname des Moduls. Tutorial
Zurückgegeben wird von der Funktion entweder true (wahr), wenn die Bibliothek erfolgreich geladen wurde, oder false (falsch) bei einem Fehlschlag. ·
HINWEIS
Sollte PHP im SAFE MODE laufen, so ist es nicht möglich, das Ming-Modul dynamisch einzubinden. In diesem Falle muss der Administrator des betreffenden Servers das Modul statisch einkompilieren.
Der Upload der Bibliothek muss im Binärmodus (Binary Mode) erfolgen. Der Binärmodus stellt sicher, dass die Datei nicht angetastet wird und keine dass systemspezifischen Konvertierungen (Zeilenumbrüche etc.) vorgenommen werden. Sollten Sie die Bibliothek im ASCII-Modus hochladen, so wird sie unbrauchbar.
8.1.2 Wichtige Informationen zu Ming An dieser Stelle möchte ich noch einige Informationen liefern, die Ihnen beim Umgang mit Ming eventuell von Nutzen sein können.
Ming mit Flash 4 Ming läuft ab Version 0.2a standardmäßig mit Flash 5 ActionScript. Wenn Sie Flash 4 ActionScript erzeugen wollen, so müssen Sie folgende Funktion vor der Ausgabe des SWF aufrufen:
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
166
Kapitel 8
//~ weiterer Code hier ?> Der Aufruf dieser Funktion teilt Ming mit, den »alten« Flash 4-Compiler zu verwenden.
Ming mit PHP Version 4.1 Ming läuft momentan noch nicht mit PHP Version > 4.1.0. Dave Hayden ist momentan dabei, das Modul an PHP 4.1.0 anzupassen. Besuchen Sie www.opaque.net/ming/ für mehr Informationen.
Ming Online-Hilfe Da das Ming-Modul einige Klassen umfasst, kann im Rahmen dieses Buches unmöglich auf jede einzelne inklusive deren Funktionen eingegangen werden. Die Online-Hilfe im chm-Format befindet sich auf der beiliegenden CD-ROM. In dieser werden alle Klassen und Funktionen ausführlich erläutert (in englischer Sprache). Die Ming Online-Hilfe befindet sich unter Software und Module\Ming\ming.chm auf der CD-ROM.
Ming-Dokumentation auf php.net Unter www.php.net/manual/en/ref.ming.php finden Sie ebenfalls Informationen zum Ming-Modul und dessen Funktionen.
8.1.3 Beispiel: Leeres SWF erzeugen Dieses Beispiel befindet sich im Ordner Beispiele\Ming\emptySWF\ auf der CD-ROM. Inhalt des PHP-Scripts: setRate(20);
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Serverseitige Erzeugung von Flash-Inhalten
167
//~ Bühnengröße definieren $myMovie->setDimension(550, 400); //~ Hintergrundfarbe definieren $myMovie->setBackground(0, 78, 152); //~ Header für SWF schicken header("Content-type: application/x-shockwave-flash"); //~ SWF an den Browser ausgeben $myMovie->output(); ?> Aufbau des Scripts: 1. Erstellen Sie eine neue PHP-Datei. 2. Zuerst muss das Ming-Modul eingebunden werden. Dies geschieht mit folgendem Code: setRate(20); //~ Bühnengröße definieren $myMovie->setDimension(550, 400); //~ Hintergrundfarbe definieren $myMovie->setBackground(0, 78, 152); Zuerst wird die Framerate (Bilder pro Sekunde) eingestellt, die das SWF nachher haben soll, dann die Bühnengröße in Pixel (hier: 550x400 Pixel) und zuletzt die Hintergrundfarbe des SWF als RGB (hier: ein dunkles Blau). 5. Nachdem alle Eigenschaften eingestellt wurden, kann das SWF erstellt bzw. ausgegeben werden.
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
168
Kapitel 8
//~ Header für SWF schicken header("Content-type: application/x-shockwave-flash"); //~ SWF an den Browser ausgeben $myMovie->output(); ?> Damit der Browser erkennt, dass jetzt Daten vom Typ Shockwave-Flash kommen und keine Text bzw. HTML-Daten, muss ein entsprechender HTTP-Header gesendet werden. Achten Sie darauf, dass vor der Ausgabe des Headers nichts anderes ausgegeben wird, da sonst das Senden fehlschlägt. Nachdem der Header gesendet wurde, können mit der Funktion output() die Daten des fertigen SWF ausgegeben werden.
8.1.4 Beispiel: Konvertierung eines JPEGs in ein SWF Dieses Beispiel befindet sich im Ordner Applikationen\Ming\jpg2swf\ auf der CD-ROM. HTML-Datei: jpg2swf Bitte wählen Sie eine JPEG-Datei! PHP-Script (jpg2swf.php):
AND
$image_type != "image/jpeg" AND
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
Serverseitige Erzeugung von Flash-Inhalten
169
$image_type != "image/pjpeg") { echo "Dies ist keine JPEG-Datei!"; exit(); } //~ Ming-Modul laden dl("./libraries/php_ming.so");
/*~ Bild öffnen. "b" bedeutet, dass die Datei im Binärmodus geöffnet wird, dies ist nur unter Windows wichtig, unter Unix/Linux wird dieser Parameter ignoriert */ $filePointer = fopen($image, "rb"); //~ Neues SWF-Objekt instanziieren $myMovie = new SWFMovie(); //~ Neues Bitmap-Objekt instanziieren $myBitmap = new SWFBitmap($filePointer); //~ Höhe des Bildes auslesen $bHeight = $myBitmap->getHeight(); //~ Breite des Bildes auslesen $bWidth = $myBitmap->getWidth(); //~ die Größe des SWF an die Größe des Bildes anpassen $myMovie->setDimension($bWidth, $bHeight); //~ Hintergrundfarbe definieren (weiß); $myMovie->setBackground(255, 255, 255); //~ Bitmap zum SWF hinzufügen $myMovie->add($myBitmap); //~ Dateiname generieren $saveName = "swf/".$image_name.".swf"; //~ SWF speichern $myMovie->save($saveName); //~ Auf neu erstelltes SWF weiterleiten header("Location: output.php?swfPath=".$saveName."&width=".$bWidth."&height=".$bHeight); ?>
DYNAMISCHE WEBSEITEN MIT FLASH UND PHP
170
Kapitel 8
Das PHP-Script (output.php): <TITLE>jpg2swf HEIGHT==$height?>> <EMBED src="=$swfPath?>" quality=high bgcolor=#FFFFFF WIDTH==$width?> HEIGHT==$height?> TYPE="application/x-shockwave-flash" PLUGINSPAGE="http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Ver sion=ShockwaveFlash">