Google Android – So funktioniert’s

Konrad Hübner, Henning Böger

Im November 2007 war es soweit: Google veröffentlichte die erste Version seines Software Development Kits (SDK) für die Mobilplattform Android. Dieser Artikel bietet einen Einstieg in die Android-Plattform. Beschrieben werden die Architektur und grundlegende Konzepte von Android. Anhand eines illustrierten Beispiels wird in die Entwicklung eingeführt.

Der ein oder andere hatte Ende letzten Jahres sicher erwartet, dass ein vollständiges Telefon vorgestellt wird, aber Google verfolgt augenscheinlich eine andere Idee. Ein vollständig quelloffenes System, programmierbar über Java, ausgestattet mit einem umfangreichen, von Google aufgepeppten API, soll das Interesse der Entwickler wecken. Eine wesentliche Annahme dabei ist, dass eine mobile Internetverbindung bald zur (bezahlbaren) Grundversorgung gehört. Die gebündelte Kreativität der Entwicklergemeinde bringt dann einen Schwung an Applikationen, Modifikationen und Tools auf den Markt, von der andere Mobilplattformen nur träumen. Und das, bevor es überhaupt ein einziges Gerät gibt, das die Android-Plattform einsetzt. Die Einreichungen zur ersten Phase der Google Android Code Challenge geben Google Recht: Die Plattform hat ein beachtliches Interesse geweckt und vielversprechende Ideen hervorgebracht. Die Rechnung scheint aufzugehen.

Warum sollten Sie sich mit Android beschäftigen? Erstens ist sicher, dass der Trend deutlich stärker zu mobilen, vernetzten Applikationen geht. Eine ständige, schnelle Internetverbindung und GPS gehören ebenso wie hochauflösende Displays und intelligente Eingabesysteme zur Grundausstattung moderner Endgeräte. Dieses Potenzial will genutzt werden. Mit der Android-Plattform wird Google den Markt aufräumen – die mächtigen Projektpartner in der Open Handset Alliance [1] lassen dies zumindest vermuten. Im Bereich der mobilen Applikationen wird also jeder über kurz oder lang über Android stolpern – ein früher Einstieg schadet demnach nicht.

Und zweitens wird einem der Einstieg in das Thema selten so leicht gemacht wie bei Android. Keine Registrierung, keine teure IDE, keine Hardware ist nötig, um in Java schnell die erste eigene Anwendung zu erstellen. Besonders hervorzuheben sind die von Google bereitgestellten APIs, welche die Mash-Up-Gedanken des Web 2.0 aufs Handy bringen: Kombiniere einfache Elemente und erhalte eine nützliche Anwendung. Dabei gilt einmal mehr: Keep it simple – es handelt sich schließlich immer noch um ein Mobiltelefon.

Was ist Android?

Android ist eine vollständige Plattform für mobile Geräte. Sie bringt ein Betriebssystem, eine Laufzeitumgebung, ein Anwendungsframework und fertige Kernanwendungen mit. Ist passende Hardware vorhanden, reicht es also, Android zu installieren, um ein Smartphone zu erhalten. Soweit die Theorie. Die passende Hardware gibt es aber noch nicht zu kaufen und die Plattform ist auch noch nicht fertig. Dennoch sollen bis zum Ende des Jahres 2008 Android-Telefone verfügbar sein. In der Zwischenzeit kann man mit dem Android SDK Anwendungen entwickeln und mit dem mitgelieferten Emulator testen.

Android ist im Umfang etwa vergleichbar mit Windows Mobile, Symbian OS oder der iPhone Plattform. Es ist allerdings darauf ausgelegt, den Anwendungsentwicklern maximalen Nutzen zu bieten: Die Plattform ist quelloffen und leicht erweiterbar. Man kann in Java programmieren. Alle Möglichkeiten der Hardware können genutzt, Applikationen nach Belieben ergänzt oder ersetzt werden (auch Telefonieapplikationen).

In der Summe erhält der Entwickler mit Android Freiheiten, die er auf anderen Plattformen nicht hat, und zum anderen erhält er Werkzeuge, mit denen er mobile Anwendungen außergewöhnlich komfortabel entwickeln kann. Beides zusammen soll dazu führen, dass die besten mobilen Anwendungen auf Basis von Android entstehen.

Abb. 1: Architektur von Android

[ header = Seite 2: Architektur der Plattform ]

Architektur der Plattform

Um einen Überblick über Android zu bekommen, muss man sich näher mit der Architektur der Plattform beschäftigen. Android besteht aus folgenden Komponenten (Abb. 1):

  • Betriebssystem: Android nutzt den Linux Kernel 2.6. Der Kernel stellt die grundlegenden Systemdienste wie Speicher- und Prozessverwaltung, Netzwerkkommunikation und die Hardwareabstraktionsschicht zur Verfügung. Als Entwickler mobiler Anwendungen kann mir das theoretisch egal sein, da meine Anwendungen nicht direkt mit dem Betriebssystem kommunizieren werden (siehe weiter unten Android Runtime). Entwickler von Treibern und Erweiterungen werden sich aber vermutlich freuen, dass Linux verwendet wird und keine obskure Eigenentwicklung.
  • Systembibliotheken: Android enthält einige C/C++-Bibliotheken, die Funktionalitäten für das Android-Laufzeitsystem bereitstellen. Zum Beispiel 3D-Bibliotheken, Medien-Codecs und anderes mehr. Als Entwickler kommt man mit diesen Bibliotheken nicht in Berührung, da sie durch die Laufzeitumgebung gekapselt sind.
  • Android Runtime: Alle Android-Anwendungen laufen in einem eigenen Prozess in einer Instanz der Android-Laufzeitumgebung. Die Laufzeitumgebung heißt Dalvik Virtual Machine (VM). Das ist eine von Google entwickelte, für mobile Geräte optimierte virtuelle Maschine, die den Android-eigenen Bytecode ausführt, den so genannten Dalvik-Bytecode. Wichtig: Die Dalvik VM bringt nicht alle Java APIs einer Java Runtime mit. Die wichtigsten APIs sind aber dabei, und man kann eigene JAR-Bibliotheken mit seiner Anwendung mitliefern.
  • Anwendungsframework: Das Anwendungsframework enthält die grundlegenden Bausteine und APIs, mit denen Android-Anwendungen entwickelt werden. Es ist damit die wichtigste Schnittstelle für alle Android-Anwendungen.
  • Anwendungen: Die Android-Plattform liefert die wichtigsten Anwendungen für ein Smartphone bereits mit: Telefonie, Kontakte, Kalender, Webbrowser, Google Maps und weitere. Alle Anwendungen werden in Java geschrieben und verwenden die Android Runtime. Es ist bisher nicht vorgesehen, dass man native Anwendungen in C/C++ schreibt, die direkt auf Systembibliotheken oder den Linux Kernel zugreifen. Eine echte Besonderheit von Android ist, dass Anwendungen nicht voneinander isoliert sind, sondern über einfache Mechanismen lose miteinander gekoppelt werden können. Entwickler können, wenn die Anwendungen entsprechend gebaut sind, einzelne Funktionalitäten anderer Anwendungen für ihre Anwendung nutzen. Beispiel: Ich möchte in meiner Anwendung die Möglichkeit bieten, einen Kontakt auszuwählen. Anstatt dafür meinen eigenen Dialog zu bauen, springe ich einfach in die Kontaktverwaltungsanwendung. Der Benutzer wählt dort den Kontakt aus, und die aufgerufene Anwendung liefert mir den ausgewählten Kontakt zurück. Auf diese Weise kann ich andere Anwendungen als Dienste betrachten und bei Bedarf in meine Anwendung integrieren.

Android erscheint vollständig. Es bringt alle Komponenten mit, um vollwertige Anwendungen auf mobilen Geräten laufen zu lassen. Android stellt eine Abstraktionsschicht für die Anwendungen bereit, sodass diese sich nicht übermäßig mit gerätespezifischen Eigenschaften anstrengen müssen. Alle Anwendungen sind gleichberechtigt, auch die mit dem System ausgelieferten machen keine Ausnahme: Das gibt dem Entwickler viel Spielraum. Entwickelt wird in Java – das verspricht eine hohe Produktivität bei der Entwicklung der Anwendungen, da die wichtigsten Java APIs verwendet werden können. Zusätzlich sind Google-Anwendungen und APIs mitgeliefert, die leicht integriert werden können (z.B. Google Maps). Vor allem die lose Kopplung der Anwendungen ist interessant: Sie ermöglicht es, bestehende Anwendungen leicht in seiner eigenen Anwendung zusammen zu integrieren und damit ähnlich Web 2.0 Mash-Ups schnell hochwertige Anwendungen zu konstruieren.

[ header = Seite 3: Bausteine einer Android-Anwendung ]

Bausteine einer Android-Anwendung

Android gibt die Struktur einer Anwendung und deren Kernbausteine vor. Jeder Entwickler muss diese Bausteine und deren Zusammenspiel kennen. Dabei gilt, dass Android-Anwendungen nicht isoliert zu betrachten sind, sondern mittels einfacher Mechanismen untereinander kommunizieren können. Abbildung 2 zeigt das Zusammenspiel.

Abb. 2: Aufbau und Kommunikation von Android-Anwendungen

  • Eine Activity ist der sicher am meisten genutzte Baustein. Er entspricht üblicherweise einer Maske auf dem Bildschirm. Die Activity trägt eine View, die das Layout und die Bedienelemente der Maske definiert. Die Activity selbst definiert, wie auf Ereignisse der View (z.B. Klick eines Buttons) reagiert werden soll, und sie kann die Inhalte der View verändern. Sie ist damit ein Kernelement der Dialogsteuerung. Eine Activity hat einen Lebenszyklus (Lifecyle). Dieser ist bei Android sehr wichtig, da die Plattform zur Optimierung des Ressourcenverbrauchs Activities jederzeit beenden kann. In einer Activity können daher Callbacks für die Lifecycle-Methoden der Plattform erstellt werden. Dies geschieht, indem die entsprechenden Methoden überschrieben werden. So ist es zum Beispiel möglich, Daten zu sichern, bevor die Plattform die Anwendung aus dem Speicher wirft.
  • Eine View ist dafür verantwortlich, einen Bereich des Bildschirms zu zeichnen und Benutzereingaben entgegenzunehmen. Ähnlich wie bei Java Swing können Container Views definiert werden, die andere Views enthalten und sie mit einer bestimmten Layout Engine zueinander anordnen. In Android können Views über XML-Dateien definiert und von einer Activity referenziert werden.
  • Intents werden dazu verwendet, um von einer Activity zu einer anderen Activity zu springen. Ein Intent beschreibt eine Operation, die eine Activity ausführen will. Beispiel: In einer Kontaktverwaltung gibt es zwei Activities, eine zum Anzeigen der Kontaktliste und eine zum Editieren eines Kontakts. Wenn der Benutzer in der Kontaktliste auf einen Kontakt klickt, löst die Activity den Intent EDIT aus, worauf die Activity mit der Kontaktpflege aufgerufen wird. Die Activities sind also nicht hart im Code miteinander verdrahtet. Die auslösende Activity weiß nicht, welche Activity letztlich den Intent behandeln wird. Das entscheidet die Plattform zur Laufzeit anhand so genannter IntentFilter. Diese legen für eine Activity fest, auf welche Intents sie reagieren sollen. Die hier vorzufindende lose Kopplung der Activities ist ein wesentliches Konzept von Android.
  • IntentReceiver können ähnlich wie Activities auf Intents reagieren, sie haben jedoch keine View. Das heißt: Sie werden nicht am Bildschirm angezeigt. Sie können aber dazu verwendet werden, um beispielsweise auf externe Ereignisse wie einen Telefonanruf zu reagieren. Sie können daraufhin zum Beispiel einen Service starten oder eine Notification anzeigen. Alternativ wäre auch denkbar, bei Anrufen von einer bestimmten Nummer einfach den Anruf abzulehnen. So hat man seine konfigurierbare Telefonruhe.
  • Ein Service ist ein Dienst, der ohne Anzeigeelemente im Hintergrund einer Anwendung läuft. Zum Beispiel soll ein MP3-Spieler die Musik auch dann abspielen, wenn andere Activities im Vordergrund sichtbar sind. Das Abspielen der Musik würde man als Service realisieren. Activities können wiederum einen Service steuern, um zum Beispiel die Musik zu starten oder anzuhalten. Services haben ähnlich wie Activities einen Lifecycle, werden aber nach Möglichkeit nicht beendet. Sollte das doch einmal passieren, startet Android den Service wieder, sobald genügend Ressourcen zur Verfügung stehen.
  • Notifications sind Benachrichtigungen, die dem Benutzer prominent am oberen Rand des Android-Bildschirms angezeigt werden, um ihn auf ein Ereignis unabhängig von der gerade laufenden Anwendung hinzuweisen. Zum Beispiel kann man den Benutzer damit darauf aufmerksam machen, dass eine SMS für ihn angekommen ist. Wenn eine Notification vom Benutzer geöffnet wird, kann diese wiederum einen Intent absetzen, der eine Activiy startet.
  • ContentProvider bieten eine Datenzugriffsschicht für Activities, IntentReceiver und Services. Android-Anwendungen können ihre Daten in einer SQL-Datenbank speichern, die vom Framework bereitgestellt wird. Activities können direkt auf diese Datenbank zugreifen. Wenn allerdings Daten auch anderen Anwendungen zur Verfügung gestellt werden sollen, ist ein ContentProvider nützlich, den man bei der Laufzeitumgebung registriert: Der ContentProvider kann anwendungsübergreifend genutzt werden, um die von ihm verwalteten Daten zu lesen und zu ändern. Zum Beispiel erlaubt es die Kontaktverwaltung anderen Anwendungen, selbst die Liste der Kontakte auszulesen oder zu ändern. Dafür stellt sie einen ContentProvider bereit.
  • Das Android-Manifest enthält die gesamte Anwendungskonfiguration in einer XML-Datei. Die Anwendungskonfiguration definiert, aus welchen Activities, IntentFiltern, IntentReceivern, Services und anderem die Anwendung aufgebaut ist und wie die Komponenten konfiguriert sind. Zum Beispiel wird hier definiert, auf welche Intents eine Activity reagieren soll. Zusätzlich wird im Manifest definiert, welche Zugriffsrechte eine Anwendung benötigt, wie zum Beispiel auf das GPS-System.
  • Ressourcen: Android liefert ein Ressourcen-Framework mit, um Ressourcen abzulegen und darauf zuzugreifen (Strings, Bilder, aber auch Layouts der Views). Es ist damit relativ einfach möglich, Ressourcen internationalisiert oder auch gerätespezifisch abzulegen.

[ header = Seite 4: Beispielanwendung ]

Beispielanwendung

Die im Folgenden entwickelte Android-Anwendung soll ein Texteingabefeld enthalten und nach Knopfdruck den Anwender mit dem eingegebenen Namen begrüßen – quasi ein erweitertes „Hello World“, um die Ansteuerung der Oberflächenelemente zu demonstrieren.

Hierfür wird die Entwicklungsumgebung eingerichtet. Die Entwicklung erfolgt auf Basis einer Eclipse-3.x-Installation. Das Android SDK steht in Versionen für Windows, MacOS X und Linux auf der Google-Android-Homepage zum Download bereit [2]. Dabei ist zu beachten, dass die SDK-Versionen in dem API nicht stabil sind, man sollte also auf jeden Fall mit der neuesten Version arbeiten. Das vorgestellte Beispiel basiert auf Version m5-rc15. Google liefert für Eclipse ein Plug-in zur Android-Entwicklung mit, das am besten über den Eclipse-Update-Mechanismus installiert wird (HELP | SOFTWARE UPDATES | FIND AND INSTALL). Die URL der Update-Site lautet https://dl-ssl.google.com/android/eclipse/. Die Plug-ins dienen der Steuerung des Emulators sowie der Erweiterung von Eclipse um spezielle Android Views und Projekte.

Nach der Installation wird das Plug-in konfiguriert. Die Einstellungen sind in Eclipse unter WINDOW | PREFERENCES | ANDROID zu finden. Hier wird der Pfad auf das SDK gesetzt. Das Plug-in bietet die einfache Ansteuerung des Emulators über eigene Views und eine Android-spezifische Perspektive namens DDMS. Die Views erreicht man über WINDOW | SHOW VIEW | OTHER | ANDROID. Die wichtigsten beiden Views sind die LogCat-View und die Device-View. Über die LogCat-View können alle Konsolenausgaben des Emulators beobachtet werden. Dort sind auch Exceptions zu sehen, die der Java-Code wirft. Für die Fehlersuche ist dies äußerst hilfreich. Über die Devices-View kann der Debug-Modus für einzelne Anwendungen angeschaltet werden. Klappt man den Emulator-Knoten auf, so werden alle laufenden Anwendungen angezeigt. Wählt man den Eintrag aus und klickt dann in der Menüleiste der View auf den grünen Käfer, so ist der Debug-Modus aktiviert und die Anwendung wird bei gesetzten Breakpoints anhalten.

Als Erstes wird ein neues Android-Projekt angelegt. Alle benötigten Strukturen werden dabei automatisch eingerichtet. Der Wizard fragt (Abb. 3) nach Package-, Activity- und Application-Namen. Jede Applikation braucht mindestens eine Start-Aktivität, um laufen zu können. Für das DemoProjekt wird das Package org.example, den Activity-Namen HelloUserActivity und den Application-Namen Hello User ausgewählt.

Abb. 3: Der Projekt-Wizard

Die Struktur eines Android-Projekts besteht aus dem Java-Code im Source-Verzeichnis sowie diversen Ressourcen-Ordnern und der Manifest-Datei. Die Ressource-Ordner enthalten Bilder, die Dialogspezifikationen im Android-spezifischen XML-Format sowie Werte-Konstanten. Für das Beispiel wird auf die Internationalisierung sowie die Anpassung an unterschiedliche Auflösungen verzichtet. Dennoch sollten von Anfang an alle Textkonstanten in die strings.xml-Datei eingetragen und nicht im Quellcode definiert werden. So ist die Internationalisierung später sehr leicht umzusetzen. Was die Bilder angeht bevorzugt Android das PNG-Format, kann aber auch mit GIF- und JPEG-Bildern umgehen.

[ header = Seite 5: User-Interface ]

User-Interface

Bei einer mobilen Anwendung ist das wichtigste Element die Bedienoberfläche. Layout und Bedienkonzept sollten in groben Zügen bereits vor Beginn der Entwicklung festgelegt werden, da Änderungen hier mühsam sind und bis auf die Anwendungslogik durchschlagen. Leitmotiv sollte dabei immer sein: So einfach wie möglich. Eine Anwendung, die intuitiv verständlich ist, wird auch gerne benutzt. Niemand will Anleitungen für Software auf seinem Handy lesen müssen.

Für das UI-Design wird eines der hilfreichsten Tools im Android-Dunstkreis verwendet: DroidDraw [3]. Die Mühe, aus XML per Hand eine ansprechende Benutzeroberfläche zu entwerfen, ist recht groß. Trotz gewisser Einschränkungen in der aktuellen Entwicklungsversion kann mit DroidDraw grafisch relativ schnell das Design erstellt werden. Wichtig: Die Elemente, auf die aus der Anwendung zugegriffen werden soll (Textfelder, Buttons, Checkboxen), müssen eine eindeutige ID erhalten. Über den Properties-Dialog in DroidDraw können neben der ID noch weitere Layout-Attribute eingestellt werden. Hier gilt es, durch Probieren und Nachlesen in der SDK-Dokumentation ein Gespür für die Layouts und die UI-Elemente zu bekommen. Für ein Grundgerüst ist DroidDraw eine gute Unterstützung, eine manuelle Nachbearbeitung der XML-Datei ist aber unumgänglich. Hier hilft der Android ResourceBuilder [4], mit dem man für alle setzbaren Attribute XML-Snippets generieren kann, denn auch hier ist die Dokumentation in Teilen sehr dünn. Selbstverständlich sind die Einstellungen auch später über den Java-Code möglich.

Das Beispiel-Layout bekommt ein Label (TextView), ein Texteingabefeld (EditText) und einen Button (Abb. 4). Ein Druck auf den Generate-Button erzeugt abschließend den gewünschten XML-Code, der in die XML-Datei main.xml im Verzeichnis res/layout in das Eclipse-Projekt kopiert wird. Eclipse führt hierbei eine Syntaxprüfung durch, um die Korrektheit sicherzustellen. Ebenso kann DroidDraw fertige Layout-Dateien laden und das Layout anzeigen.

Abb. 4: Das Layout in DroidDraw

Im nächsten Schritt werden die benötigten String-Konstanten definiert, um alle Texte aus dem Java-Teil herauszulösen und über die Ressourcemechanismen von Android bereitzustellen. Listing 1 zeigt die fertige Datei mit Texten für das Label, den Button, den Begrüßungstext ohne Namen und einen Hinweistext, der im Texteingabefeld erscheint, solange noch keine Eingabe erfolgt ist.

<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">Hello User</string>
<string name="field_label">Ihr Name: </string>
<string name="button_label">Gruß anzeigen</string>
<string name="greeting_text">Hallo</string>
<string name="hint_text">Namen eingeben</string>
</resources>
	

Nach der Definition der String-Konstanten muss das Layout nochmals angepasst werden. Die TextView bekommt nun aus den Konstanten einen Text zugewiesen und alle Views müssen – falls noch nicht geschehen – möglichst aussagekräftige IDs erhalten (Listing 2).

<?xml version="1.0" encoding="utf-8"?>
<AbsoluteLayout android:id="@+id/widget0"
android:layout_width="fill_parent" android:layout_height="fill_parent"
xmlns:android="http://schemas.android.com/apk/res/android">
<TextView android:id="@+id/textField"
android:layout_width="wrap_content" android:textSize="16sp"
android:layout_height="wrap_content"
android:text="@string/field_label" android:layout_x="20px"
android:layout_y="22px">
</TextView>
<EditText android:id="@+id/nameField" android:layout_width="160px"
android:layout_height="wrap_content" android:hint="@string/hint_text"
android:textSize="18sp" android:layout_x="100px"
android:layout_y="12px">
</EditText>
<Button android:id="@+id/button" android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/button_label" android:layout_x="120px"
android:layout_y="102px">
</Button>
</AbsoluteLayout>

Dem aufmerksamen Entwickler wird im Source Folder neben der bei der Erstellung angegebenen Aktivitäten-Klasse eine Klasse mit dem Namen R auffallen. Diese Klasse ist generiert und stellt die nötigen Daten zur Verbindung von UI, Bildern und definierten Texten zur Verfügung. Jedes Element aus dem res-Verzeichnis wird dabei auf eine applikationsspezifische Integer-ID gemappt. Über diese ID kann vom Code aus auf jede Ressource einfach zugegriffen werden. Die Datei bleibt unberührt, da sie komplett generiert wird. Die für das Beispiel erzeugten Konstanten sind auf Abbildung 5 mit abgebildet.

Abb. 5: Das fertige Eclipse-Projekt mit generierten Resourcen

[ header = Seite 6: Der Java-Teil + Fazit ]

Der Java-Teil

Im nächsten Schritt wird die Anwendungslogik entwickelt. Das Grundgerüst einer Android-Anwendung besteht aus einer Activity, in der die onCreate()-Methode überschrieben wird. In ihr wird die View über setContentView() an die Activity gebunden. Jede XML-Datei im Verzeichnis res/layout steht über die R-Klasse als eigene, ansprechbare Layout-View zur Verfügung. Für das Beispiel wird zudem Zugriff auf das Texteingabefeld und den Button benötigt. Über die generierten IDs kann auf die Felder zugegriffen werden. Der Button erhält einen OnClickListener für die auszuführende Aktion beim Drücken des Knopfs. Um dem Anwender mit seinem eingegebenen Namen einen Begrüßungstext anzuzeigen, wird auf einen so genannten Toast zurückgegriffen. Mit Toasts werden Popup-Meldungen für einen gewissen Zeitraum angezeigt und verschwinden danach wieder. Für die Befüllung des Toast-Texts wird eine der Textkonstanten sowie der im Eingabefeld eingegebene Text verwendet. In Listing 3 ist der komplette Quelltext der Klasse HelloUserActivity abgebildet.

package com.bmw.swll6.maven.util;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class HelloUserActivity extends Activity {

private EditText mNameField;
private Button mButton;

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

mNameField = (EditText) findViewById(R.id.nameField);
mButton = (Button) findViewById(R.id.button);

mButton.setOnClickListener(new View.OnClickListener() {

public void onClick(final View pView) {
Toast.makeText(HelloUserActivity.this,
getString(R.string.greeting_text) + " "
+ mNameField.getText(), Toast.LENGTH_LONG).show();
}
});
}
}
	

Nachdem alle Teile zusammengefügt sind und das Projekt fehlerfrei kompiliert, kann die Anwendung gestartet werden. Dazu wird einfach mit der rechten Maustaste auf den Projektordner geklickt und RUN AS | ANDROID APPLICATION ausgewählt. Dann heißt es warten, bis der Emulator läuft und die Anwendung gestartet ist (Abb. 6). Damit ist die Beispielanwendung fertig.

Abb. 6: Der Android-Emulator

Fazit

Google ist mit der Android-Plattform mit ihrem ganzheitlichen Ansatz ein guter Wurf gelungen. Besonders die durch Activities und Intents eingeführte lose Kopplung der Anwendungen hebt Android von anderen Mobilplattformen positiv ab. Ein weiterer Vorteil ist der vollständige Zugriff auf alle Funktionen des Geräts über Java. Auf Applikationsebene bieten die von Google bereitgestellten Anwendungen wie Google Maps mit seinem GeoCoder eine interessante und breite Basis für eigene Entwicklungen.

Natürlich muss sich Android weiter entwickeln, das SDK ist noch im Betastatus: Das API muss reifen und von Google vollständig dokumentiert werden. Die Nagelprobe wird Android erleben, wenn die ersten Geräte auf dem Markt sind. Dann wird sich zeigen, wie gut das Konzept trägt und ob die benötigte Performance auf der Hardware erreicht wird.

Erstaunlich ist, wie groß die Community in diesem frühen Stadium bereits ist. Ob über die Google-Mailinglisten oder die größten Foren [5],[6] – eine schnelle und oft hilfreiche Antwort ist sicher. Man kann einiges aus dem SDK herausholen, die Entwickler tun dies bereits und erstellen spannende Anwendungen. Android kann viel und wird sein Potenzial noch voll entfalten. Es lohnt sich insofern wirklich, einen aufmerksamen Blick auf Android zu werfen.

Konrad Hübner und Henning Böger sind Mitarbeiter der sd&m AG und seit mehreren Jahren in Softwareprojekten tätig. Die Google Android Code Challenge hat ihnen schlaflose Nächte bereitet und zu diesem Artikel geführt.
Geschrieben von
Konrad Hübner, Henning Böger
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.