Navigation: Home » Anleitung Teil 3 : Apache Ant mit FlashDevelop

Anleitung Teil 3 : Apache Ant mit FlashDevelop

Geschrieben in Programmierung
12.08.10, 09:00

Nun beschreibe ich einen Weg, das Projekt mit Apache Ant zu veröffentlichen.

Wir benötigen dafür Ant “Apache-Ant (http://ant.apache.org/)”. Ich verwende momentan Apache Ant 1.8.1.

Apache Ant vorbereiten

Als erstes wird Ant installiert, bzw. es muss nur entpackt werden, zum Beispiel in C:\Programme\. Damit Ant ohne Pfadangabe gestartet werden kann, tragen wir diesen in die Systemvariablen ein.
Dazu klicken wir mit der rechten Maustaste auf Arbeitsplatz -> Eigenschaften und auf die Registrierkarte Erweitert. Nun sollte das Fenster wie im folgendem Bild aussehen, dort gehen wir auf Umgebungsvariablen.

Ein weiteres Fenster öffnet sich, dort suchen wir unter Systemvariablen den Eintrag Path und machen einen Doppelklick drauf.

Jetzt muss nur noch der Eintrag unter Wert der Variablen: mit ;C:\Programme\apache-ant-1.8.1\bin\ erweitert und mit OK bestätigt werden.

FlashDevelop vorbereiten

Da wir später ein Release-Build per Knopfdruck erstellen wollen, müssen wir ein Button in die ToolBar.xml eintragen. Diese liegt im Installationsverzeichnis von FlashDevelop, für gewöhnlich in C:\Programme.

In dieser Datei muss nun der folgende Code vor </toolbar> eingefügt werden.

<seperator />
 <button label="Ant Build (Release)" click="RunProcessCaptured" image="487" tag="c:\windows\system32\cmd.exe;/c $(Quote)ant -buildfile $(Quote)$(ProjectDir)/ant/build.xml$(Quote) release$(Quote)" />

Nach einem Neustart von FlashDevelop sollte dann ein neuer Button zu sehen sein.

  1. label wird als Tooltip angezeigt.
  2. Was beim Klicken passiert steht in click, hier soll ein Prozess ausgeführt werden.
  3. image=”487″ bedeutet, dass das Icon 487 aus der Iconsammlung genommen wird.
  4. tag sagt dem RunProcessCaptured was er ausführen soll. Er soll die cmd.exe mit dem Befehl “ant -buildfile “$(ProjectDir)/build/build.xml” release. In etwa so: cmd.exe starte bitte bitte ant mit der build.xml und führe das target release aus. $(Quote) ist ein Anführungszeichen und $(ProjectDir) der absolute Pfad zum Projekt für FlashDevelop.

Möchte man per Knopfdruck noch ein anderes target starten, so müsste ein Weiterer Knopf hinzugefügt werden. Wer gerne mein Plugin benutzen möchte kann sich dies unter http://www.flashdevelop.de/programmierung/ant-plugin-fuer-flashdevelop.html anschauen und installieren, somit bleibt einem der ganze Schritt FlashDevelop vorbereiten erspart.

Das Projekt Stechen mit Ant erweitern

Warum wollen wir das Projekt überhaupt mit Ant erstellen, wenn FlashDevelop das auch kann?

trace Ausgaben könnten Informationen preisgeben, die der Anwender missbrauchen könnte, um sich z. B. Vorteile zu verschaffen, daher müssten wir diese vorher löschen. Der DEBUGMODE muss für den Release von true auf false und wieder zurück geändert werden. Unsere Versionsnummer braucht eine Erhöhung. Dies und noch viel mehr kann Ant für uns übernehmen.

D. h. Ant soll für Stechen:

  1. DEBUGMODE auf false stellen.
  2. trace Ausgaben löschen.
  3. Versionsnummer erhöhen.
  4. Release Version erstellen und als ZIP speichern.
  5. Debug Version erstellen und starten.

Also erstellen wir zu erst ein neues Verzeichnis und nennen es ant, dort legen wir alle Dateien für Ant hinein. Eine build.xml (New XML File…), eine build.property (New Empty File…) und eine build.number.

Vorab: hier findet ihr die Anleitung von Apache Ant http://ant.apache.org/manual

build.xml

Ein Ant Projekt besteht immer aus einer XML Datei, wir haben unsere build.xml genannt.

<?xml version="1.0" encoding="utf-8" ?>
<!-- Jedes Ant Script wird von einem Project Tag umschlossen.
	Dem geben wir den Namen Stechen und als default Target debug.
	Das Hauptverzeichnis soll das gesamte Projektverzeichnis sein, also ../.
-->
<project name="Stechen" default="debug" basedir="../">

<!--
Vordefinierte Variablen können in Dateien ausgelagert werden.
Variablen werden mit ${name xyz} angesprochen.
Geladen oder erstellt werden diese mit dem Tag property,
sie können aber auch als Parameter übergeben werden.
Mit file geben wir an dass eine Datei geladen werden soll.
Wir wollen die build.property im Hauptverzeichnis unter ant laden.
-->
	<property file="${basedir}/ant/build.property" />

<!--
Dann erstellen wir noch drei weitere Variablen, die jeweils
den Pfad zu bin, lib und src angeben, ausgehend vom Hauptverzeichnis.
-->
	<property name="bin" value="${basedir}/bin" />
	<property name="lib" value="${basedir}/lib" />
	<property name="src" value="${basedir}/src" />

<!--
Nun beginnen wir mit dem ersten Target und nennen ihn debug.
Eine kleine Beschreibung mit description vergeben wir auch noch.
debug soll:
1. die Buildnummer erhöhen
2. das Projekt kompilieren
3. die SWF starten
-->
	<target name="debug" description="Erstellt eine Debug Version">

<!--
Mit dem Tag antcall sagen wir dem debug er soll einen anderes Target ausführen.
Man kann sich dies wie Funktionsaufrufe vorstellen. Hier wollen wir gerne buildnumber
ausführen und übergeben noch einen Parameter mit dem namen increment und dem Wert build.
Dieser kann später im Target buildnumber genutzt werden.
-->
		<antcall target="buildnumber">
			<param name="increment" value="build" />
		</antcall>

<!--
Nun starten wir compile und übergeben drei Variablen, dessen Bedeutung später erläutert werden.
-->
		<antcall target="compile">
			<param name="debugmode" value="true" />
			<param name="srcpath" value="${src}" />
			<param name="benchmark" value="false" />
		</antcall>

<!--
Mit exec können wir andere Programme starten.
executable gibt das zu startende Programm an.
failonerror besagt, dass dies bei Fehlern abgebrochen werden soll.
Mit arg wird dem Programm alles übergeben, was in line steht.
Aufgelöst würde hier stehen <arg line="../bin/Stechen.swf"
-->
		<exec executable="${flashPlayerDebug}" failonerror="true">
			<arg line="${bin}/${outputfile}" />
		</exec>
	</target>

<!--
Unser release Target soll bevor es ausgeführt wird noch clean ausführen, dies besagt depends.
-->
	<target name="release" depends="clean" description="Erstellt eine Release Version">

<!--
buildnumber ausführen für patch Nummer
-->
		<antcall target="buildnumber">
			<param name="increment" value="patch" />
		</antcall>

<!--
Die soeben mit buildnumber geänderte Datei muss nun noch in das temporäre Verzeichnis kopiert werden.
Dateien kopiert man mit copyfile.
src ist die Datei, die kopiert werden soll.
dest ist das Ziel.
Mit forceoverwrite überscheiben wir die bestehende Datei.
-->
		<copyfile src="${src}/BuildVersion.as" dest="${basedir}/tmp/BuildVersion.as" forceoverwrite="true" />

<!--
Nun kompilieren wir die Dateien im tmp Verzeichnis, welches wir mit clean erstellt haben.
-->
		<antcall target="compile">
			<param name="debugmode" value="false" />
			<param name="srcpath" value="${basedir}/tmp" />
			<param name="benchmark" value="true" />
		</antcall>

<!--
Anschließend kann das temporäre Verzeichnis gelöscht werden, mit delete.
-->
		<delete dir="${basedir}/tmp" includeEmptyDirs="true" />
	</target>

<!--
compile soll das Projekt mit dem Adobe Flex Compiler kompilieren. Den Source Path übergeben wir mit dem antcall, debugmode und benchmark ebenfalls.
Eine detaillierte Beschreibung bekommt ihr, in dem ihr im cmd [mxmlc -help list details] oder [mxmlc -help list aliases details] eingebt.
-sp alle benötigten Sourcen, das src oder tmp Verzeichnis und der Tweener.
-include-libraries unsere benötigten SWC's, hier nur die assets.swc
Dann kommen Angaben zur SWF, ja könnten in die build.property ausgelagert werden.
Zum Schluss noch den Einstiegspunkt angeben und mit -o die Ausgabedatei Stechen.swf
-->
	<target name="compile">
		<exec executable="${mxmlc}" failonerror="true">
			<arg line="
						-sp '${srcpath}' ${addClassPaths} 

						-include-libraries '${lib}/assets.swc'

						-default-size 300 400
						-default-frame-rate 31
						-default-background-color 0xFFFFFF
						-debug=${debugmode}
						-incremental=false
						-benchmark=${benchmark}
						-target-player=10.0.0

						'${srcpath}/Main.as'
						-o '${bin}/${outputfile}'
						"/>
		</exec>
	</target>

<!--
clean soll:
1. src Verzeichnis zwischenspeichern, für die Änderungen.
2. DEBUGMODE auf false setzen
3. trace Ausgaben löschen
4. Projekt als ZIP speichern
-->
	<target name="clean">
		<property name="tmp" value="${basedir}/tmp" />

<!--
Zur Sicherheit altes tmp löschen.
-->
		<delete dir="${basedir}/tmp" includeEmptyDirs="true" />

<!--
Verzeichnis kopieren von dir nach todir.
-->
		<copy todir="${tmp}">
			<fileset dir="${src}" />
		</copy>

<!--
Mit replace können Zeichenketten gesucht und ersetzt werden.
In der Datai file und Kodierung encoding.
token wird gesucht und mit value ersetzt.
-->
		<replace file="${tmp}/Main.as" encoding="UTF-8" token="DEBUGMODE:Boolean = true" value="DEBUGMODE:Boolean = false" />

<!--
Mit replaceregexp können reguläre Ausdrücke benutzt werden.
Wir wollen alle trace Ausgaben löschen, suchen also mit dem Ausdruck in match nach trace(....) und ersetzen diesen mit replace.
flags -g sucht und ersetzt in der ganzen Datei.
fileset dir bedeutet nichts anderes als im gesamten tmp Verzeichnis zu suchen.
-->
		<replaceregexp match="trace\(.*\)" replace="" flags="-g">
			<fileset dir="${basedir}/tmp" />
		</replaceregexp>

<!--
build.number auslesen.
Mit zip ein ZIP File erstellen, unter destfile bin/release/Stechen_(versionsnummer).zip.
basedir wird gezipt.
exludes werden ausgeschlossen, unsere Releaseversionen. Debug habe ich wohl nicht mehr gemacht.
INFO: mit dem Tag ftp könnte man auch Dateien auf einem Server schieben.
-->
		<property file="${basedir}/ant/build.number" />
		<zip destfile="${bin}/release/${ant.project.name}_${major}.${minor}.${patch}-${build}.zip" basedir="${bin}" excludes="release/**,debug/**" />

	</target>

<!--
buildnumber soll für release die patch Nummer erhöhen und im debug die build Nummer.
-->
	<target name="buildnumber">

<!--
propertyfile build.number laden.
entry nimmt einen Eintrag aus der Datei, der mit key angegeben wird. Wir übergeben diesen als param und haben die Variable increment genannt.
Mit type setzen wir den Datentype des Eintrages fest, wir brauchen ein Integer.
default setzt den Wert auf 0 falls keiner vorhanden ist.
Dann wollen wir mit operation + den Wert um eins erhöhen.
-->
		<propertyfile file="${basedir}/ant/build.number">
			<entry key="${increment}" type="int" default="0" operation="+" />
		</propertyfile>

<!--
Die neuen Versionsnummern auslesen und wie gehabt, unsere BuildVersion.as aktualisieren.
-->
		<property file="${basedir}/ant/build.number" />
		<replaceregexp file="${src}/BuildVersion.as"
							match="VERSION:String = '(.*)'"
							replace="VERSION:String = '${major}.${minor}.${patch}-${build}'"
							byline="true"  />
	</target>

</project>

build.property

Die build.property ist eine normale Textdatei und nicht sonderlich spannend. Ant liest diese aus und verwendet die Variablen.

#Name der Ausgabedatei
outputfile = Stechen.swf

#Zusätzliche Klassenpfade
addClassPaths = 'c:/Dokumente und Einstellungen/akhon/Eigene Dateien/Classes/greensock-tweening-platform-as3/'

#Flash Player, Debug Player und die Version
flashPlayer = c:/Programme/Adobe/Adobe Flash CS4/Players FlashPlayer.exe
flashPlayerDebug = c:/Develop/flashplayer_10_sa_debug.exe
playerVersion = 10

#Der Pfad zum Flex SDK
flexSDK = c:/Develop/flex_sdk_3.4.1.10084
#Adobe Flex Compiler
#Auch hier können Variablen benutzt werden
mxmlc = ${flexSDK}/bin/mxmlc.exe

build.number

Die Nummern werden von Ant ausgelesen und in die BuildVersion.as eingefügt. Erhöht werden in diesem Projekt nur patch und build

#Thu, 12 Aug 2010 09:38:54 +0200
#Build Number
#Tue Aug 10 21:23:55 CEST 2010
major=0
minor=0
patch=1
build=9

ProjektDateien

Projekt Stechen mit Ant runterladen

Teilen macht glücklich!
  • facebook
  • Twitter
  • Delicious
  • Digg
  • StumbleUpon
  • Google Bookmarks
  • email
  • RSS

Tags: , , , ,

Kommentar hinterlassen

CAPTCHA-Bild
*