1. Objekterzeugung innerhalb der Schleifen vermeiden
2. Mehrfache Objekterzeugung von oft benutzen Objekten in der Klasse vemeiden (z.B.: findViewById()). Diese sollten am besten direkt als Klassenvariablen, und somit nur einmal, initialisiert werden.

for (int i = 0; i < array.length; i++) { … }

int arrayLenght = array.length;
for (int i = 0; i < arrayLength; i++) { … }

Unsere App ist bereits lauffähig. Aber es fehlt noch ein entscheidender Punkt, bevor wir uns der Programmlogik annehmen. Die beiden Auswahlboxen sind momentan ohne Inhalt und somit zwecklos. Das wollen wir natürlich ändern.

Die Auswahlboxen können als Inhalt Daten aus einer Datenbank oder aus einem Array (Auflistung) entgegennehmen. Da wir später noch unsere App mehrsprachig machen wollen, werden wir die Währungen als Ressourcen ablegen.

Dafür befolgen Sie die folgenden Schritte:

1. Klicken Sie mit der rechten Maustaste auf das Projekt in der Package-Explorer Ansicht.
2. Wählen Sie den Punkt “Android Tools” (ganz unten im Kontextmenü).
3. Wählen Sie im Untermenü “New Resource File ...“.
4. Geben Sie als File “arrays” ein.
5. Wählen Sie als Typ “Values” aus.
6. Klicken Sie auf “Finish“.

Damit legen wir eine neue Ressource-Datei, in der wir Auflistungen speichern werden. Wir benötigen insgesamt 2 Auflistungen. In der neuen Datei legen Sie entweder über die graphische Oberfläche über den “Add” Knopf ein neues StringArray (siehe Bilder) mit dem Namen “waehrung“, oder Sie geben die Werte direkt als XML-Code ein. Die XML-Darstellungen sehen Sie weiter unten.

array.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="waehrung">
        <item>EUR - Euro</item>
        <item>USD - Amerikanische Dollar</item>
        <item>AUD - Australische Dollar</item>
        <item>RUB - Russische Rubel</item>
        <item>CUD - Kanadische Dollar</item>
        <item>GBP - Englische Pfund</item>
    </string-array>
    <string-array name="waehrung_kurs">
        <item>1</item>
        <item>1.3795</item>
        <item>1.3314</item>
        <item>42.1941</item>
        <item>1.3495</item>
        <item>0.8738</item>
    </string-array>
</resources>

Nun können wir die beiden Auswahllisten mit dem Inhalt der ersten Auslistung füllen. Die zweite Liste benötigen wir später im Code. Es sind die Währungskurse in Bezug auf Euro, die wir für die Umrechnung benötigen.

Um die Auswahlliste an eine Auflistung zu binden, müssen wir nur in unseren Layout-Datei “main.xml” bei den beiden Auswahllisten (Spinner) folgende Zeile (Zeile Nr. 6) hinzufügen.

<Spinner
	android:layout_height="wrap_content"
	android:layout_width="0dp"
	android:layout_weight="1"
	android:id="@+id/selWaehrungStart"
	android:entries="@array/waehrung">
</Spinner>

Wenn Sie jetzt die App starten, können Sie bereits die Ausgangs- und Zielwährung wählen (siehe Bild).

Nun können wir uns den Java-Quellcode widmen. Als Erstes sollte unser “Berechnen” Knopf auf das Klicken reagieren. Dazu registrieren wir einen Listener (Zuhörer), der praktisch darauf wartet, bis der Benutzer eine Aktion ausführt. Dazu müssen wir als Erstes die Instanz des Knopfes ermitteln. Nun kommt uns zugute, dass wir unsere Views mit einer eindeutigen ID versehen haben.

Aus dem Java Code zu einer Activity könne wir jederzeit eine Referenz auf ein View mit einer ID ermitteln. Dafür stellt die Activity die Methode findViewById(ID). Da die Methode die Basisklasse “View” zurückliefert, müssen wir den Rückgabewert noch auf das zu erwartende View (in unserem Fall Button) kasten (Button cmdBerechnen = (Button)findViewById(R.id.cmdBerechnen);). Wie an diesem Beispiel zu sehen ist, greifen wir auf die automatisch generierte “R“-Klasse, die uns die Referenzen auf unsere Ressourcen zur Verfügung stellt. Dabei sind folgende oft verwendete Referenzen wichtig:

• R.id : Referenzen auf die Views der Layouts. Im Layout sind das die android:id="" Attribute
• R.layout : Referenzen auf die Layout-Dateien
• R.string : Referenzen auf unsere definierten Texte
• R.array : Referenzen auf unsere definierte Auflistungen
• R.color : Referenzen auf die Farben
• R.drawable : Referenzen auf die Bilder
• und einige weitere. Weitere Infos dazu finden Sie unter: developer.android.com

Den Listener fügen Sie mit der folgen Zeile hinzu:

cmdBerechnen.setOnClickListener(new OnClickListener() {
	public void onClick(View v) {
		kursBerechnen();
	}
});

Wir rufen in diesem unsere eigene Methode auf, die die Berechnung und die Ausgabe übernimmt. Das Ganze passiert in der onCreate Methode, die beim Erstellen einer Activity als Erstes aufgerufen wird (Lebenszyklen einer Activity wird in einem anderen Workshop erklärt). Schauen wir uns diese genauer an.

HauptActivity.java

package de.webducer.android.wrechner;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

public class HauptActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Init();
    }

    /**
     * Initialisierung des Menüs (wird nur ein mal aufgerufen)
     */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
    	MenuInflater inflater = new MenuInflater(this);
    	inflater.inflate(R.menu.menu, menu);
    	return super.onCreateOptionsMenu(menu);
    }

    /**
     * Reagieren auf ein Klick auf ein Menüeintrag
     */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
    	switch (item.getItemId()) {
    	// Ergebnisliste löschen
		case R.id.optLoeschen:
			TextView ergebnisse = (TextView)findViewById(R.id.txtErgebnisse);
			ergebnisse.setText("");

			break;

		// Programm schließen
		case R.id.optSchliessen:
			this.finish();

			break;

		default:
			break;
		}
    	return true;
    }

    /**
     * Initialisierung der Oberfläche
     */
    private void Init(){
    	// Button mit einem Listener verbinden
    	Button cmdBerechnen = (Button)findViewById(R.id.cmdBerechnen);
    	cmdBerechnen.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				kursBerechnen();
			}
		});
    }

    /**
     * Berechnung und Ausgabe des Ergebnisses
     */
    private void kursBerechnen(){
    	// Elemente auslesen
    	EditText txtBetrag = (EditText)findViewById(R.id.txtBetrag);
    	TextView txtErgebnis = (TextView)findViewById(R.id.txtErgebnisse);
    	Spinner selWaehrungStart = (Spinner)findViewById(R.id.selWaehrungStart);
    	Spinner selWaehrungEnde = (Spinner)findViewById(R.id.selWaehrungEnde);

    	Boolean failure = false;

    	// Uwandlung des Betrages in eine Zahl
    	String betragText = txtBetrag.getText().toString();
    	Double betrag = 0d;
    	if (betragText != null && betragText != "") {
    		try {
    			betrag = Double.parseDouble(betragText);
			} catch (NumberFormatException e) {
				Toast.makeText(this, R.string.err_betarg_format, Toast.LENGTH_LONG).show();
				failure = true;
			}
		}

    	// Bestimmen der Ausgangs- und Zielwährung
    	int wahrungStart = selWaehrungStart.getSelectedItemPosition();
    	int waehrungEnde = selWaehrungEnde.getSelectedItemPosition();

    	// Bestimmen des jeweiligen Wechselkurses
    	String kursStartText = getResources().getStringArray(R.array.waehrung_kurs)[wahrungStart];
    	String kursEndeText = getResources().getStringArray(R.array.waehrung_kurs)[waehrungEnde];

    	// Umwandlung des Kurses in eine Zahl
    	Double kursStart = 0d;
    	Double kursEnde = 0d;
    	if (kursStartText != null && kursStartText != "" && !failure) {
			try {
				kursStart = Double.parseDouble(kursStartText);
			} catch (NumberFormatException e) {
				Toast.makeText(this, R.string.err_kurs_format, Toast.LENGTH_LONG).show();
				failure = true;
			}
		}
    	if (kursEndeText != null && kursEndeText != "" && !failure) {
			try {
				kursEnde = Double.parseDouble(kursEndeText);
			} catch (NumberFormatException e) {
				Toast.makeText(this, R.string.err_kurs_format, Toast.LENGTH_LONG).show();
				failure = true;
			}
		}

    	if(!failure){
	    	// Umrechnung
	    	Double ergebnis = betrag / kursStart * kursEnde;

	    	// Ergebnis ausgeben
	    	StringBuilder ergebnisText = new StringBuilder();
	    	ergebnisText.append(getResources().getStringArray(R.array.waehrung)[wahrungStart].subSequence(0, 3))
	    		.append(" ")
	    		.append(String.format("%.2f", betrag))
	    		.append(" = ")
	    		.append(getResources().getStringArray(R.array.waehrung)[waehrungEnde].substring(0, 3))
	    		.append(" ")
	    		.append(String.format("%.2f", ergebnis))
	    		.append("\n");
	    	txtErgebnis.setText(txtErgebnis.getText() + ergebnisText.toString());
    	}
    }
}

In der Zeile 21 wird durch den Aufruf der Methode setContentView(R.layout.main); wiesen wir unseren Activity HauptActivity.java ein Layout zu, den wir wieder über die generierte Klasse “R” ansprechen.

Der Aufruf unserer eigenen Methode Init() in der Zeile 23 setzt den Listener für unseren Berechnungs-Knopf. Nun wenden wir uns der eigentlichen Berechnung zu (Zeilen 75 bis 142).

Als Erstes holen wir uns die Referenzen zu allen Views, die wir für unsere Berechnung benötigen (Betrag, Ausgangswährung, Endwährung und Ergebnisfeld).

In der Zeile 87 erhalten wir durch den Aufruf der Methode getText() den Betrag für die Umrechnung. Das ist allerdings ein Textfeld und wir benötigen eine Zahl. Aus diesem Grund konvertieren wir den erhaltenen Text in ein Double-Format (mit der vorherigen Prüfung, ob der Text überhaupt eingegeben wurde, Zeile 89).

In den Zeilen 99 und 100 erhalten wir den Index des ausgewählten Eintrages aus den Auswahlboxen der Währung. Jetzt kommt uns der zweite Array, in dem wir die Kurse definiert haben, zugute. Dieser ist genauso von der Reihenfolge her aufgebaut, wie das Währungs-Array. Nun können wir durch den Index aus den Zeilen 99 und 100 die Kurse ermitteln (Zeilen 103 und 104). Diese sind wiederum Texte und müssen zuerst in Double konvertiert werden, wie bereit beim Betrag.

Wenn alle Konvertierungen ohne Fehler durchgelaufen sind, berechnen wir nun in der Zeile 128 den umgerechneten Betrag. Um eine schöne Anzeige zu erhalten, formatieren wir nur ein wenig unsere Ausgabe. Die Anzeige soll dann in etwa folgendermassen aussehen:

EUR 125,00 = USD 172,44

Damit wir auch eine Geschichte unserer Berechnungen erhalten, hängen wir in der Zeile 140 unser Ergebnis an den vorhandenen Text an.

Um dem Benutzer zu signalisieren, dass mit der Berechnung etwas schief gelaufen ist, erzeugen wir bei einem Konvertierungsfehler einen Toast (kleine Benachrichtigung, die kurz auf dem Bildschirm erscheint). Das erfolgt in den Zeilen 93, 113 und 121. Wenn Sie einen solchen Fehler provozieren wollen, tauschen Sie einfach in der array.xml-Datei in dem Werte-Array die Punkte durch die Kommas aus (erzeugt Fehler beim Konvertieren).

Lokalisierung

Die Lokalisierung ist unter Android relativ einfach gelöst. Die Ressourcen, die keinen Länder-Postfox haben, gehören zu der Standardsprache (in unseren Fall Deutsch). Die Standardsprache muss immer vollständig sein. Weitere Sprachen dagegen nicht. Wird eine spezielle Übersetzung nicht gefunden, wird die der Standard-Übersetzung genommen.

In unserer App müssen die Daten aus der strings.xml und arrays.xml Dateien übersetzt werden. Dafür klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Android Tools -> New Ressource File... . Wie im Bild zu sehen ist, muss für neue Sprache nun unter “Available Qualifiers” “Language” auswählen und auf der rechten Seite den zweistelligen Ländercode eingeben (“en” für Englisch). Nun kann der Inhalt der beiden Dateien in die neuen kopiert werden und die Werte übersetzt werden. Die neuen Dateien landen im Ordner “res/values-en“.

strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
	<!-- Globale Strings -->
	<string name="app_name">Currency Calculator</string>

	<!-- View Texte -->
    <string name="betrag_eingeben">Please type the value to calculate!</string>
    <string name="cmd_berechnen">Calculate</string>

    <!-- Menü -->
    <string name="opt_loeschen">Clear Result List</string>
    <string name="opt_loeschen_kurz">Clear</string>
    <string name="opt_schliessen">Close App</string>
    <string name="opt_schliessen_kurz">Close</string>

    <!-- Fehlertexte -->
    <string name="err_betarg_format">The value has wrong format!</string>
    <string name="err_kurs_format">The currency value has wrong format!</string>
</resources>

arrays.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="waehrung">
        <item>EUR - Euro</item>
        <item>USD - American Dollar</item>
        <item>AUD - Australian Dollar</item>
        <item>RUB - Russian Rubel</item>
        <item>CUD - Canadian Dollar</item>
        <item>GBP - Great Britain Pound</item>
    </string-array>
</resources>

Menü

Nun gehen wir an das Menü. Dafür erstellen wir wieder eine neue Android Ressource-Datei von Typ Menü. Diese XML-Datei landet im Ordner “res/menu“.

menu.xml

<?xml version="1.0" encoding="utf-8"?>
<menu
  xmlns:android="http://schemas.android.com/apk/res/android">
    <item
    	android:title="@string/opt_loeschen"
    	android:titleCondensed="@string/opt_loeschen_kurz"
    	android:id="@+id/optLoeschen"
    	android:icon="@drawable/opt_clear" />
    <item
    	android:title="@string/opt_schliessen"
    	android:titleCondensed="@string/opt_schliessen_kurz"
    	android:id="@+id/optSchliessen"
    	android:icon="@drawable/opt_close" />
</menu>

In unseren Activity-Java-Datei müssen nur noch wenige Zeilen hinzugefügt werden, um dem Menü ein Leben einzuhauchen. In den Zeilen 30 bis 34 wir das Menü initialisiert (ähnlich, wie das Layout in der onCreate-Methode). Dafür dient die überschriebene Methode onCreateOptionsMenu(). Unter Optionsmenü versteht man unter Android das Menü, das durch das Betätigen der Menütaste erscheint.

Die Auswertung, welches der Menüpunkte nun ausgewählt wurde, erfolgt in der überschriebenen Methode onOptionsItemSelected(). Über die Item-ID können wir bestimmen, was nun ausgewählt wurde und abhängig davon unseren Code ausführen (hier ist ein CASE-Konstrukt sehr gut geeignet, um die Menüpunkte zu unterscheiden und den Code übersichtlich zu halten). Für das Schließen unseren App benötigen wir nur eine Zeile mit this.finish() (Zeile 51). Um die Ergebnisse zurückzusetzen, müssen wir wieder die Referenz auf das View holen und deren Text auf einen leeren Text setzen (Zeilen 44 und 45).

Damit ist unsere App so weit funktionsfähig und einsatzbereit. Die Kurse können sehr einfach in der XML-Datei angepasst und erweitert werden.

GitHub Projekt-Repository

Projektbeschreibung (Zielsetzung)

In diesem Beitrag wird ein einfacher Währungsrechner erstellt. Folgende Aufgaben / Voraussetzungen muss die fertige App erfüllen:

• Eingabe eines Betrages zum Umrechnen
• Validierung der Eingaben (nur Zahlen)
  • Auswahl der Ausgangs- und Zielwährung
• Berechnung des Betrages in der Zielwährung
• Ausgabe der Berechnung
  • Die letzen Ergebnisse in einer Liste ausgeben
• Löschen der Ergebnisliste über ein Menü
• Beenden der App über ein Menü
• Mehrsprachigkeit

Durch diese relativ einfache Anwendung werden die unter Android am meisten benutzte Elemente vorgestellt.

Anlegen des Projektes unter Eclipse

Eine genaue Beschreibung, wie Sie Eclipse auf Ihrem System einrichten, finden Sie unter “Android: Eclipse installieren und einrichten“. Im Beitrag “Android: Neues Projekt anlegen” finden Sie die Beschreibung, wie Sie ein neues Android-Projekt mithilfe des Assistenten unter Eclipse anlegen. Für das folgende Projekt sollten Sie die folgenden Werte beim Anlegen des Projektes angeben, um den Beschreibungen und Code-Ausschnitten besser folgen zu können:

• Project name: Waehrungsrechner
• Contents: Create new project in workspace
• Build target: Android 2.2 (API Level 8 )
• Application name: Waehrungsrechner
• Package name: de.webducer.android.wrechner
• Create Activity (angehackt): HauptActivity
• Min SDK Version: 8

Nach der Neuanlage des Projektes wird der erste Bildschirm bereits mit einem Element, dass den Text “Hallo World” enthält. Nun können Sie das Projekt zum ersten Mal starten. Dafür gehen Sie wie folgt vor:

1. Markieren Sie im “Package Explorer” das Projekt
2. Klicken Sie mit der rechten Maustaste darauf und
3. wählen Sie im Kontextmenü den Punkt “Run as” -> “Android Application”

Nach einiger Zeit startet zuerst der eingerichtete Emulator (das kann abhängig vom Rechner auch einige Minuten dauern). Danach startet im Emulator das Programm. Schließen den Emulator nicht, dann wird die neue Version sehr schnell auch auf dem Emulator angezeigt.

Aber nun der Reihe nach. Zuerst erkläre ich die Datei-Struktur von unserem Projekt.

Ordner und Dateistruktur des Projektes

Projektstruktur

src

In diesem Verzeichnis liegen die Quellcode-Dateien zu Ihrer App (Java-Dateien). Im Moment sollte in diesem Ordner nur die Datei “HauptActivity.java” liegen (im entsprechenden Package “de.webducer.android.wrechner”).

gen

Das ist ein automatisch generiertes Verzeichnis von Android. Die automatisch generierte Klasse “R” beinhaltet die Verweise auf die Ressourcen-Variablen und dient zum Zugriff auf diese aus dem Quellcode heraus. Zu den Ressourcen gehören unter anderen die übersetzbaren Strings, Layouts, Farben, Arrays, Bilder usw.

Android 2.2

In diesem Ordner ist die Android-Bibliothek abgelegt. Abhängig von der ausgewählten Android-SDK-Version wird eine andere Nummer angezeigt.

assets

In diesem Ordner werden Ressourcen abgelegt, die nicht über den Ressourcen-Manager verwaltet werden und in Unterverzeichnisse gegliedert werden können.

res

In diesem Ordner werden Ressourcen abgelegt, die über den Android-Ressource-Manager zur Verfügung gestellt werden und in der R.-Klasse abgebildet werden. Die einzelnen Unterordner werden weiter unten beschrieben.

drawable-XX

In diesen Ordnern werden die Bilder für die App gespeichert. XX steht dabei für eine bestimmte Ausflösungsdichte und wird dynamisch abhängig vom Auflösungsvermögen des Zielbildschirms ausgelesen.

layout

In diesem Ordner liegen die Layout-Definitionen für unsere App. In unserem Fall sollte am Anfang nur die Datei “main.xml” vorliegen.

values

In diesem Ordner werden unterschiedliche Werttypen gespeichert. Unter anderem sind hier die Strings-Definitionen für die Mehrsprachigkeit einer App definiert. Weitere Wertgruppen sind zum Beispiel Farben, Designs, Arrays usw.

AndroidManifest.xml

Diese Datei definiert unsere App und regelt unter anderem auch die notwendigen Berechtigungen.

Das Layout

Währungsrechner-Layout

Unser Layout für die App besteht aus folgenden Elementen (Widgets):

• EditText: Für die Eingabe des Betrages für die Umrechnung
• Spinner: Zwei Auswahlboxen für die Auswahl der Ausgangs- und der Zielwährung
• Button: Knopf, um die Umrechnung anzustoßen
• TextView: Bereich, in dem die Ergebnisse angezeigt werden (zusammen mit älteren Umrechnungen)

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
    <EditText
    	android:layout_height="wrap_content"
    	android:id="@+id/txtBetrag"
    	android:layout_width="fill_parent"
    	android:hint="@string/betrag_eingeben"
    	android:inputType="numberDecimal">
    </EditText>
    <LinearLayout
    	android:orientation="horizontal"
    	android:weightSum="3"
    	android:layout_height="wrap_content"
    	android:layout_width="fill_parent">
	    <Spinner
	    	android:layout_height="wrap_content"
	    	android:layout_width="0dp"
	    	android:layout_weight="1"
	    	android:id="@+id/selWaehrungStart">
	    </Spinner>
	    <Spinner
	    	android:layout_height="wrap_content"
	    	android:layout_width="0dp"
	    	android:layout_weight="1"
	    	android:id="@+id/selWaehrungEnde">
	    </Spinner>
	    <Button
	    	android:text="@string/cmd_berechnen"
	    	android:id="@+id/cmdBerechnen"
	    	android:layout_width="0dp"
	    	android:layout_weight="1"
	    	android:layout_height="wrap_content">
	    </Button>
	</LinearLayout>
	<ScrollView
		android:layout_height="fill_parent"
		android:layout_width="fill_parent">
	    <TextView
	    	android:id="@+id/txtErgebnisse"
	    	android:layout_width="fill_parent"
	    	android:layout_height="fill_parent"
	    	android:gravity="top">
	    </TextView>
	</ScrollView>
</LinearLayout>

Ein Android-Layout besteht aus einfachen Views (wie EditText, Button usw.) und den sogenannten View-Gruppen-Elementen, die weitere Elemente enthalten dürfen. Das oberste Element ist immer eine View-Gruppe. In unserem Fall ist es ein LinearLayour. Diese Gruppe richtet die enthaltenen Elemente abhängig von der Orientierung neben- (horizontal) oder übereinander (vertical) an (Zeilen 4 und 17). Das Linear-Layout Element aus der Zeile 2 ordnen somit alle enthaltenen Elemente untereinander. Und das Linear-Layout aus Zeile 15 ordnet die 3 enthaltenen Elemente nebeneinander.

Die Angabe in allen Views android:layout_width bestimmt die Bereite des Elementes, android:layout_height die Höhe. Es sind folgende Werte möglich:

• fill_parent (oder match_parent): View nimmt die gesamte Breite / Höhe ein, die das Elternelement zur Verfügung stellt.
• wrap_content: View nimmt die Breite / Höhe des eigenen Inhaltes ein.
• Wert in Pixel (px) oder Device Independent Pixel (dp / dip).

Somit nimmt unser LinearLayout aus Zeile 2 die gesamte Breite und Höhe (ganzer Bildschirm), das EditText dagegen zwar die gesamte Breite, aber nur eigene Höhe ein.

In der Zeile 10 sehen wir ein spezielles Konstrukt (android:id="@+id/txtBetrag"). Mit dieser Angabe “@+id/” teilen wir dem Compiler mit, dass dieses Element eine eindeutige ID erhalten soll, gefolgt von dem Namen, den wir frei vergeben können. Über diese ID können wir später auf das View aus dem Quellcode zugreifen (R.id.txtBetrag).

In der Zeile 12 (android:hint="@string/betrag_eingeben") kommt wieder ein spezieller Android-Konstrukt. Über die Angabe “@string/” können wir auf die String-Ressourcen aus dem “res“-Ordner zugreifen. Das sind die übersetzten Text-Platzhalter. Die string.xml folgt weiter unten. Die Angabe android:hint legt einen Hinweistext fest, der nach der Eingabe der ersten Zahlen verschwindet.

Die Angabe in der Zeile 13 (android:inputType="numberDecimal") legen wir fest, dass im Eingabefeld nur positive Zahlen eingegeben werden dürfen.

Damit wir die 3 Views nebeneinander und in der gleichen Breite darstellen, nutzen wir statt der absoluten Breitenangabe (z.B. Zeile 22 android:layout_width="0dp") eine relative Angabe zum Eleternelemet. LinearLayout aus Zeile 15 definiert, dass den Kindelementen eine Gewichtungssumme von 3 zur Verfügung gestellt wird (Zeile 17 android:weightSum="3"). Die 3 Views haben jeweils eine Gewichtung von 1 (Zeile 23 android:layout_weight="1"), also genau 1/3 der Gesamtgewichtung.

In der Zeile 40 ist das TextView innerhalb eines ScrollView (View-Gruppe) platziert. Das erlaubt uns später durch die Ergebnisse zu scrollen, falls es mehr sein werden, als der Platz auf dem Bildschirm erlaubt.

Mit der Zeile 47 (android:gravity="top") geben wir an, dass der Text oben (im Bezug zum Elternelement) platziert werden soll.

strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="betrag_eingeben">Bitte den Betrag hier eingeben!</string>
    <string name="app_name">Währungsrechner</string>
    <string name="cmd_berechnen">Berechnen</string>
</resources>

Android: Erste App (Währungsrechner) – Teil 2

Neues Android-Projekt wird über das Menü „File“ → „New“ → „Android Project“ angelegt (siehe Bild). Sollte dieser Menüpunkt nicht sichtbar sein, gehen Sie auf „Others“ und wählen Sie dann im folgenden Dialog „Android Project“.

Im folgenden Assistenten müssen folgende Angaben gemacht werden (siehe Bilder):

• Project name: Projektname ohne Sonderzeichen (z.B.: MeineApp)
• Build Target: Compiler-Version, mit der die App kompiliert wird (z.B.: 8 für Android 2.2 Geräte)
• Application name: Bezeichnung der App, so wie diese im Menü des Smartphones erscheinen soll (z.B.: Meine Erste App)
• Package name: Hierarchische Bezeichnung des Java-Packages. Oft als umgekehrte URL angegeben (z.B.:  de.meinedomein.appname)
• Min SDK version: minimale Anforderungen an das Gerät (z.B.: 4 für Android 1.6)

Für komplexere Apps ist es empfehlenswert zur App auch TestUnits zu schreiben, um bei neueren Versionen die Funktionalität automatisiert testen zu können. Das kann im nachfolgenden Dialog mit erledigt (siehe Bild) oder später dem Projekt hinzugefügt werden.

Installation von Eclipse

1. Eclipse Classic ab Version 3.5 herunterladen (www.eclipse.org/downloads/).
2. Die heruntergeladene Datei in einen Ordner entpacken (z.B.: C:\Entwicklung\Eclipse unter Windows, oder /Users/Shared/Entwicklung/Eclipse unter Mac OS X).
3. Eclipse starten und das Standard-Workplace (z.B.: C:\Entwicklung\Android unter Windows oder /Users/Shared/Entwicklung/Android unter Mac OS X) vergeben.

Installation von Android Development Tools (ADT)

1. Android SDK für das gewünschte Betriebssystem herunterladen (http://developer.android.com/sdk/index.html).
2. Die heruntergeladene Datei in einen Ordner entpacken (z.B.: C:\Entwicklung\AndroidSDK unter Windows oder /Users/Shared/Entwicklung/AndroidSDK unter Mac OS X).
3. Eclipse starten und zu Help → Install New Software gehen.
4. Bei „Work with:“ auf „Add...“ klicken, um neues Software-Repository hinzuzufügen (siehe Bild).
5. Namen frei vergeben und als „Location“ https://dl-ssl.google.com/android/eclipse/ eingeben.
6. OK klicken.
7. Developer Tools als zu installierende Komponenten auswählen (es dauert einige Zeit, bis die Repository eingelesen wird).
8. Die Installation mit „Next“ → „Next“ → „Accept“ und „Finish“ abschließen.
9. Eclipse neu starten.
10. Gehen Sie zu Preferences (unter Winsdows über Window → Preferences, unter Mac OS X über Eclipse → Prefenrences zu erreichen.
11. Gehen Sie zum Punkt „Android“ und tragen Sie da den Speicherort von Android-SDK ein (nach dem Vorschlag wäre es unter Windows der Ordner C:\Entwicklung\AndroidSDK und unter Mac OS X /Users/Shared/Entwicklung/AndroidSDK).
12. Nun gehen Sie zu „Window“ → „Android-SDK Manager“ und installieren Sie die benötigten (z.B.: Android 1.6 und Android 2.2) oder alle SDK-Versionen.
13. Nach dem Neustart von Eclipse gehen Sie wieder zu „Window“ → „AVD Manager“.
14. Legen Sie mit „New“ die virtuellen Android-Geräte, für die Sie entwickeln möchten (z.B.: ein Android 2.2 Gerät mit WXGA Auflösung [800x480] und 2GB SD-Karte). Sie können auch mehrere virtuelle Geräte anlegen und beim Start eines Android-Projektes dann eins davon auswählen.
15. Damit sind alle Vorbereitungen für die Android-Programmierung getroffen.

Update

• 22. Januar 2012: Anpassungen an ADT Revision 16

Installation

Vor der Windows 7 Installation sollte der ASUS Empfehlung nach, zuerst das aktuelle Update für BIOS installiert werden (momentan Version 2204).

Die Installation von Windows 7 auf einem Netbook gestaltet sich endlich sehr einfach und bedarf kein DVD-Laufwerk mehr, wie es bei XP oder Vista der Fall war. Microsoft liefert hierfür ein Tool namens “Windows 7 USB/DVD Download Tool“, mit dem eine ISO-Datei von Wndows 7 direkt auf ein USB-Stick transferiert und dieses bootbar gemacht wird. Das konnte ich auf dem damals noch installierten Windows XP auf dem Netbook ohne Weiteres durchführen. Das einzige Problem stellt sich wahrscheinlich für die meisten, das “Beschaffen” eines ISO-Abbildes von Windows 7. Diejenigen, die einen Vertrag mit Microsoft haben (z.B. Action Pack), können die ISO direkt herunterladen. Wenn man Windows 7 bei Microsoft und einigen Partnern in der digitalen Version bestellt, bekommt man auch ein ISO-Abbild zu Download angeboten. Alle anderen müssen, wohl oder übel, auf einem Rechner mit DVD-Laufwerk eine ISO-Datei von der Original-Windows 7 DVD erstellen (z.B. mit Nero oder InfraRecorder unter Windows oder Burn unter MacOS X).

Um vom USB-Stick zu installieren, muss beim ASUS EeePC 1000H beim Start des Netbooks die “ESC”-Taste gedrückt werden. Dann erscheint ein Menü zur Auswahl des Boot-Laufwerkes (Festplatte, SD-Karte, falls eingesteckt, externes DVD-Laufwerk, falls angeschlossen und USB-Stick). Die weitere Windows 7 Installation verläuft, als ob man Windows 7 von der DVD installieren würde.

Nach der Installation wurden die komplette Hardware ,ohne zusätzliche Treiber, direkt erkannt und das Netbook war soforteinsatzbereit. ASUS liefert aber auch direkt Windows 7 Treiber.

Windows 7 Vorteile gegenüber Windows XP

Aufwachen

Windows 7 scheint im Alltag flotter zu arbeiten, als Windows XP auf demselben Gerät es tat. Das gilt insbesondere für den von mir oft eingesetzten Bereitschaftsmodus (Suspend to RAM). Das Netbook wacht in der Regel (es gibt nur selten Ausnahmen) in weniger als 5 Sekunden auf. Bis ich mich neu eingeloggt habe (1-2 Sekunden), ist auch das WLAN wieder da. Unter Windows XP musste ich zum Teil über 15 Sekunden nach dem Anmelden auf eine neue Verbindung zum WLAN warten.

In über 6 Monaten Einsatz ist das Gerät kein einziges Mal abgestürzt. Und das Gerät läuft oft über eine Woche ohne Herunterfahren (nur Bereitschaft, wenn dieser mal nicht benötigt wird).

Akku

Der Akku hält erfreulicherweise genauso lange/kurz, wie auch unter Windows XP. Mit WLAN und ausgeschalteten Bluetooth hält dieser bei ständigem im Internet surfen und Last.fm hören ca. 3,5 Stunden durch. Die theoretischen 7 Stunden hielt das Netbook auch unter Windows XP nie durch. Am Anfang waren es knapp 5,5 – 6 Stunden, dann pendelte sich der Akku aber auf ca. 3,5 – 4 Stunden.

Internet

Im Internet bin ich mit Firefox und Opera unterwegs. Es unterstützen aber mittlerweile alle Browser. Es geht um den Vollbild-Modus. Bei IE, Firefox, Opera, Chrome wechselt man zu und von diesem Modus durch Drücken der “F11″-Taste. Mittlerweile surfe ich nur in diesem Modus.

Bei Chrome und Opera muss man leider den Vollbild-Modus verlassen, um eine neue Adresse einzugeben. Bei Firefox und IE reicht es mit der Maus nach oben zu gehen. Dann erscheint die Adressleiste und man kann die neue Adresse eingeben.

Windows 7 Einschränkungen

Arbeitsspeicher

Den 1GB RAM merkt man bei Windows 7 eher schneller als unter Windows XP. Wenn man Firefox mit 3-4 Tabs startet (ca. 250MB verbrauch), dazu noch OpenOffice auf hat (ca. 150MB) und iTunes startet, ist Schluss mit lustig. RAM ist voll und es macht kein Spaß mehr mit dem Gerät zu arbeiten. Meine nächste Anschaffung werden wohl 2GB RAM für mein Netbook sein :-)

Auflösung

Eine weitere, ab und zu sehr hinderlicher, Einschränkung ist die Auflösung. Unter Windows XP konnte man die Auflösung auch höher drehen, als das Bildschirm es eigentlich könnte (1024×768). Das geht mit den ASUS Treibern leider nicht mehr. Man kann zwar auf 800×600 herunter schalten, aber nicht höher, als die native Auflösung des Netbooks. Bei Programmen, die eine Auflösung von mehr als 1024×600 verlangen gibt es dann nur zwei Auswege:

1. Anschließen eines externen Bildschirms, das eine höhere Auflösung hat,
2. oder Installation eines alternativen Grafiktreibers (findet man in einigen EeePC Foren).

Ich habe mich für die erste Variante entschieden, da ich erstens nicht so viele Programme habe, die das verlangen, und zweitens ich bereits einen externen Bildschirm habe, denn ich dafür einsetzen kann.

Als weitere Maßnahme habe ich die Startleiste recht angeordnet, sodass mir die 600 Pixel Höhe auch wirklich zur Verfügung stehen.

Langsames Aufwachen

Es passiert sehr selten, aber ab und zu schon, dass das Netbook über 30 Sekunden zum Aufwachen braucht. Dann ist dieser aber ganz normal weiter benutzbar. In den über 6 Monaten täglichen Einsatzes passierte es noch kein einziges Mal, dass das Netbook gar nicht mehr aufwachte oder mit einem Blue Screen sich verabschiedete.

Nur wenn man das RAM ausreizt und das Betriebssystem zum Cachen auf die Festplatte gezwungen wird, ist es ab und zu schneller den Rechner hart auszuschalten (langes Drücken auf den Ausschaltknopf) und neu zu starten, als zu warten, bis die notwendigen Befehle (Programme beenden und Neustarten) vom Betriebssystem umgesetzt werden. Mit der Zeit kennt man aber die Grenzen des 1GB sehr gut und vermeidet solche “Ausrutscher”.

Treiber

ASUS schein momentan noch Probleme mit zumindest einem Treiber zu haben. Nach der Installation von “ASUS Instant Key Utility” wird bei mir beim Start von Windows immer die Meldung gezeigt, dass der Touchpad Treiber nicht gefunden werden kann. Es sind allerdings alle bei ASUS verfügbare (auch für den Touchpad) Treiber installiert. Entweder ist hier das Utility, oder der Treiber defekt. Und es ist kein Update in Sicht.

Fazit

Im Ganzen bin ich sehr mit Windows 7 auf meinem Netbook zufrieden. 2GB RAM sind zwar zu empfehlen, man kann aber auch mit 1GB RAM relativ gut damit arbeiten, wenn man ein paar Vorsichtsmaßnahmen trifft (nur wenige Programme parallel laufen lassen).

Wer eine freie Windows 7 Lizenz noch hat, würde ich zum Umstieg von Windows XP auf Windows 7 raten, besonders da die Installation mittlerweile ohne Probleme auch von einem USB-Stick klappt.

Zertifikatübersicht

Heute bin ich mit einem Problem gestoßen. Ich habe mir für meine zwei Haupt-Email-Adressen Zertifikate bei trustcenter.de bestellt.  Naturgemäß lauten beide auf meinen Namen. Theoretisch sollte es damit auch keine Probleme geben, da beide ja auf unterschiedliche Email-Adressen ausgestellt sind.

Auf dem Mac unter Mail gab es auch keine Probleme. Beide Zertifikate wurden problemlos importiert und konnten zum Signieren und Verschlüsseln benutzt werden.

Problem

Zertifikatzuordnung

Auf dem EeePC bin ich vor Kurzem von Windows Live-Mail auf Thunderbird 3.0 umgestiegen. Der Import verlief auch ohne Probleme und es wurden beide Zertifikate in der Übersicht angezeigt. Das Problem taucht auf, wenn man versucht die Zertifikate den einzelnen Email-Adressen zuzuweisen. In der Drop-Down-Liste erscheint nur ein einziges Zertifikat statt der beiden importierten.

Einzeln importiert funktionieren diese problemlos. Zusammen importiert, wird nur ein Zertifikat angezeigt.

Nach langer Recherche konnte die Ursache in der Bildung der Drop-Down-Liste von Thunderbird festgestellt werden. Zur Bildung der Liste werden bei Thunderbird nur Vor- und Nachnahme benutzt (CN), aber nicht die erweiterten Felder des Zertifikates. Viele andere Zertifikathersteller schreiben in die CN noch weitere Daten, sodass das beschriebene Problem meines Wissens nur bei trustcenter.de auftritt. Die Auszeichnung, wie trustcenter.de dies tut, entsprich der Empfehlung des Zertifikatstandards.

Lösung

Allgeminer Name

Um das Problem bei Thunderbird und trustcenter.de zu umschiffen, habe ich eins von meinen Zertifikaten gesperrt und ein neues beantragt. Dieses Mal aber in dem Feld Vorname nicht nur meinen Vornamen eingegeben, sondern “Herr …”.

Nach dem neuen Import hat Thunderbird nun beide Zertifikate richtig aufgelistet und ich konnte diese den jeweiligen Email-Adressen zuordnen.

Alternativer Name

1. Benutzer-Verzeichnis eines Benutzers verschieben.

Bild 1: Systemeinstellungen: Benutzer

Melden Sie sich am besten als ein anderer Benutzer, als der, den Sie “umziehen” möchten.

Öffne Sie die Systemeinstellungen und gehen Sie auf das Punkt Benutzer (siehe Bild 1). Unter Benutzer schalten Sie zuerst die Änderungsfunktion frei (das geschlossene Schloss unten links anklicken und mit Administratorrechten freigeben). Nun können Sie unter den Benutzer auswählen, dessen Benutzerordner Sie verschieben möchten. Klicken Sie auf diesen mit der rechten Maustaste (Kontextmenü) oder “Ctrl +  linke Maustaste”. Im Kontextmenü den Punkt “Erweiterte Optionen” auswählen. Es gibt ja nur diesen Kontextmenü-Eintrag :-) (siehe Bild 2).

Bild 2: Erweiterte Optionen

Im neuen Unterfenster kann unter anderem auch der Benutzerordner neu festgelegt werden (siehe Bild 3).

Bild 3: Ordner ändern

Der Zielordner muss auf dabei bereits vorhanden sein.

Diese Methode hat einen entscheidenden Nachteil. Für jeden neu angelegten Benutzer muss die Prozedur wiederholt werden. Das ist zwar im häuslichen Bereich bei 2-3 Benutzern vertretbar, bei mehr Benutzern empfehle ich aber die zweite Methode: “Umlenken des gesamten /Users Ordners”.

2. Umlenken des gesamten /Users Ordners

Für diese Methode müssen wir uns des Terminals bemühen, da die Umlenkung des /User-Ordners durch einen so genannten symbolischen Link geschehen wird.

Als Erstes meldet man sich als Administrator an. Nach der Anmeldung sollten keine Programme im Hintergrund laufen (Mail usw.), da sonst das Löschen nicht richtig funktioniert (/Users wird sofort wieder neu angelegt). Das einzige Programm, das laufen soll, ist ein Terminalfenster.

Im zweiten Schritt wird das /Users-Verzeichnis auf die Zielpartition kopiert. Entweder über das Terminal oder auch mit dem Finder.

# sudo cp -Rp /Users /Volumes/NeuePartition/Users

Als Nächstes muss das “alte” /Users-Verzeichnis gelöscht werden. Das erledigt man auch am besten im Terminal-Fenster.

# sudo rm -R /Users

Im letzten Schritt legt man das Symbolische Link an, damit das Verzeichnis /Users auf den Ordner auf der anderen Partition zeigt.

# sudo ln -s /Volumes/NeuePartition/Users/ /Users

Jetzt nur noch abmelden und neu anmelden. Alle Benutzer liegen nun auch der anderen Partition, auch neu angelegte.

Wer auf Nummer sicher gehen will, sollte diese Operationen entweder von einer Installation auf einer externen HDD starten oder von der Boot-DVD (Terminalfenster aufrufen, bevor die Installation anfängt). Dann sägt man sprichwörtlich nicht an dem Ast, auf dem man gerade sitzt.

In diesem Fall muss /Users durch /Volumes/SystempartitionName/Users ersetzt werden.

Auf demselben Weg kann auf Wunsch auch das Programm-Verzeichnis auf eine andere Partition “verschoben” werden.

Nach der Neuinstallation des Systems muss man nur den symbolischen Link neu setzten und alle Benutzer (incl. aller deren Einstellungen) sind wieder da.

Ich hoffe dieser Beitrag hat einigen geholfen, das Mac OS X noch ein wenig komfortabler zu machen.

WARNUNG: Das Arbeiten im Terminal mit administrativen Rechten erfolgt auf eigene Gefahr. Jeder, der sich auch das Terminal begibt, sollte wissen, was er mit dem System mach, da es hier keinen doppelten Boden und keine Sicherheitsabfragen gibt. Ein SuperUser darf eben ALLES machen, ohne Nachfragen.

Die Lösung liegt darin, das Feature, die Mac-Partitionen zu sehen, temporär auszuschalten. Dazu muss im Ordner:

c:\Windows\System32\Drivers

In diesem Ordner muss die Datei AppleMNT.sys umbenannt werden. Nach dem Neustrat von Windows, werden die Mac-Partitionen nicht mehr erkannt und man kann den SP3 wie gewohnt installieren. Nach der Installation kann die Datei AppleMNT wieder zurück umbenannt werden.

Die Problematik ist auch bei Apple Support gut erklärt.

Die zweite Möglichkeit liegt bei Bootcamp. Den Assistenten gestartet, der meldet aber:

“Das Startvolume kann weder partitioniert noch in einer Einzelpartition wiederhergestellt werden.
Für die Installation von Windows muss das Startvolume entweder ein als Mac OS-Extended (Journaled) formatiertes Einzelvolume oder bereits durch den Boot Camp-Assistenten partitioniert sein.”

Nach einiger Suche im Internet war die Ursache relativ schnell gefunden. Bootcamp funktioniert nur, wenn auf der Festplatte max. 2 Partitionen vorliegen (eine davon Windows Partition). Bei meiner Installation habe ich allerdings noch eine dritte Partition, auf der das User-Verzeichnis liegt. Somit war der Assistent nutzlos.

Weitere Recherchen ergaben dann 3 mögliche Vorgehensweisen:

1. Benutzung von nur 2 Partitionen (Mac + Windows).
2. Herumbasteln an der boot.ini, damit Windows von der richtigen Partition startet.
3. Ein alternativer Bootmanager.

Da ich in Zukunft flexibel bleiben möchte (Parallelinstallation von weiteren Betriebssystemen – Windows 7, Ubuntu usw.), habe ich mich für die 3. Variante entschieden.

Nach einiger Suche bin ich auf den Bootloader rEFIt gestossen. Nach der einfachen Installation des rEFIt Bootloaders auf die Mac OS X Systempartition habe ich noch rEFIt aktiviert, damit dieser immer erscheint.

Dafür musste ich unter Terminal folgendes ausführen:

cd /efi/refit/
enable-always.sh

Nach dem Anlegen der 3. Partition für Windows (mit Festplattendienstprogramm) startete ich die Windows-Installation von der CD. Nach dem ersten Neustrat während der Installation tauchte schon Windows als Startoption in rEFIt. Unter Windows wurde ganz normal dann alles installiert, incl. der Treiber von der Mac OS X DVD.

Das einzige Problem, dass bei der Installation von Windows XP bei mir auftrat, war die Installation von SP 3 mit den Treibern von Mac OS X 10.6 (Snow Leopard). Wie das funktioniert, beschreibe ich im nächsten Beitrag.

Auf der rEFIt Projekt-Homepage steht, dass es manchmal bei Mac OS X Updates zu Störungen kommen kann. Dann muss rEFIt einfach neu installiert werden. Beim Update von 10.6 auf 10.6.1 traten keine Komplikationen auf.

Um diesen Mangel zu beseitigen, benutzte ich schon seit Jahren unter Windows den Duden Korrektor (seit Version 3.5) für OpenOffice. Unter Windows klappt so weit alles gut, da der XP bis dahin praktisch nur in 32-Bit-Version lief.

Seit über 3 Jahren nutze ich vermehrt Linux, als primäres Betriebssystem, und seit einem Jahr noch Mac OS X 10.5 (Leopard) für meine Frau. Also wurde kurzerhand der Duden Korrektor (Version 5.0 mittlerweile) auch auf diese Systeme installiert, theoretisch. Bei Mac gibt es keine Probleme. Die Erweiterung läuft auf 64-Bit.

Unter Linux ist ein 64-Bit-System dagegen eine absolute Bremse. Es funktioniert einfach nicht. Auch konnte ich bis jetzt keine Workarounds finden, die eine funktionierende Umgebung erzeugen. Unter 32-Bit läuft es dagegen ohne Probleme (EeePC 1000H).

Die Anfragen an Duden Verlag direkt ergaben nichts. Es kommt nur die Antwort, das 64-Bit-Systeme nicht unterstützt werden, auch nicht in der Zukunft. Mittlerweile steht sogar in den Systemanforderungen (Version 6.0), dass Windows XP und Vista nur in den 32-Bit-Versionen unterstützt werden. Bei Linux wird merkwürdigerweise keine solche Ausnahme angegeben.

P.S.: Ein schneller Test der Version 5.0 mit OpenOffice 3.1 unter Windows 7 x64 RC1 zeigte, dass auch hier keine Inkompatibilitäten auftreten.

SanDisk Ulta Backup 32GB

Mittlerweile stehen auch Testberichte von 3 weiteren Testern zur Verfügung:

Erfahrungsbericht des SanDisk Ultra Backup 32GB als Festplattenersatz (von Legionen)

TecChannel Lesertest: SanDisk Ultra Backup 32 GByte (von Linuxgirl)

Lesertest 32 Gbyte SanDisk Ultra Backup USB-Stick (Test)

Vor kurzen wurde mir aber eine Aufgabe gestellt, die nicht mehr so einfach zu lösen war. TYPOlight sollte auf einem Windows 2003 Server laufen, und möglichst mit Windows Bordmitteln. Das hieß nichts anderes, als dass CMS unter IIS 6.0 und MS SQL 2005 laufen sollte.

Die Verwendung der MS SQL Datenbank scheiterte nach mehreren Versuchen komplett. Da fehlt einfach noch die Erfahrung in der Community. Es ist zwar ein Abstraktionslayer für die MS Datenbank vorhanden, aber bis jetzt gibt es keine positiven Rückmeldungen, dass TYPOlight wirklich damit läuft, und vor allem, wie man dieses einrichtet. Vielleich finde ich noch in meiner Freizeit ein wenig Zeit und probiere es zum Laufen zu bekommen.

Als erstes Testsystem benutzte ich Windows XP mit IIS 5.0.  Grundsätzlich läuft TYPOlight auch unter IIS 5.0, allerdings mit mehr Einschränkungen, als unter IIS 6.0. Auf beiden Windowsumgebungen wurde PHP 5.3 und MySQL 5.0 verwendet (Version 5.1 hat einen defekten Windows Installer, der unter Server 2003 die Installation versagt).

Der einzige Unterschied zwischen IIS 5.0 und IIS 6.0, den ich feststellen konnte, war, dass es unter IIS 5.0 keine Suchmaschinenfreundliche URLs möglich sind. Man muss immer “Keine Seitenaliase verwenden” aktivieren, damit die Seiten überhaupt aufgerufen werden können. Somit ergeben sich aber folgende URLs:
www.domain.de/index.php?id=123

Unter IIS 6.0 können suchmaschinenfreundliche URLs verwendet werden, so wie diese standardmäßig von TYPOlight generiert werden (ohne Zuhilfenahme von HTACCESS).
www.domain.de/index.php/alias.html

Weiterhin müssen für den TYPOlight Ordner (oder nur tl_files und tmp Ordner) die Rechte für den IIS-Benutzer (Vollzugriff) gesetzt werden, damit TYPOlight in diese Ordner auch schreiben kann. Wer die Dateien über die integrierte Verwaltung hoch laden will, wird hier auf mein anderes Eintrag verwiesen, damit die PHP-Temp-Einstellung richtig funktioniert.

Solange man MySQL als Datenbank einsetzt, spricht eigentlich nichts dagegen den IIS als Webserver zu nutzen. Microsoft ist ja immer mehr bemüht auch PHP direkt in Visual Studio und andere Produkte einzubinden, sodass eine bessere Zusammenarbeit zu erwarten ist. Für eine leichte Installation ist sowohl FastCGI als auch PHP 5.2 über den Microsoft Web-Installer verfügbar (www.microsoft.com/web). Die einzige Schwierigkeit, die noch bleibt, ist die Unterstützung von .htaccess Dateien, die man von Apache her kennt und die von vielen PHP-Projekten für die Generierung freundlicher URLs verwendet werden. Es gibt zwar schon ISAPI Erweiterungen die htaccess nachbilden, aber zumindest bei TYPOlight ist es noch nicht ausreichend, um 100% Funktionalität und Stabilität zu gewährleisten.

Zugriffsberechtigungen überprüft, stimmt alles, also blieb nichts anderes übrig, als zu googln. Der erste Hinweis kam, dass in der PHP.ini ein Temp-Ordner für Uploads definiert ist, auf den der IIS-Benutzer aber keine Schreibrechte hat (c:\Windows\Temp). Also in der PHP.ini den Ordner auf c:\Upload-Temp geändert und dem IIS-Benutzer auf diesen Ordner volle Rechte vergeben. Zwecklos. Es landen weiterhin 0kB Dateien im Zierordner. Auch ein Neustart brachte keine Besserung.

Nach mehreren Stunden Recherche im Internet kam der entscheidende Hinweis, dass der Temp Ordner unbedingt innerhalb des Root-Verzeichnisses der aufrufenden Homepage liegen muss, sonst kann IIS in Verbindung mit PHP keine temporären Daten in diesen schreiben.

Die Änderung der PHP.ini-Datei führte nun zum gewünschten Ergebnis. Der Upload funktioniert nun einwandfrei.