Entwicklungsumgebung

MOBILE DEVELOPMENT
Android-Apps und Eclipse
Entwicklungsumgebung
Google empfiehlt Eclipse in Verbindung mit dem Android Development Toolkit (ADT) als
Entwicklungsumgebung zur Entwicklung von Android-Apps. Von Bettina Zimmermann
AUTORIN
Bettina Zimmermann
ist Software-Entwicklerin im JavaUmfeld und seit 2002 in der ITBranche tätig.
Inhalt
Android-Apps und Eclipse.
Eingabe der Daten zum Download
des ADT-Plug-ins (Bild 2)
82
U
m mit der Entwicklung von Android-Apps starten zu können, benötigen Sie als Erstes eine lauffähige
Entwicklungsumgebung, wie zum Beispiel Eclipse und die Android-Entwicklungswerkzeuge (ADT-Plug-in, Android SDK, Android Platform, SDK-Platform-Tools). Wenn Sie noch keine Entwicklungsumgebung haben, ist der einfachste Weg dazu, das ADT Bundle herunterzuladen (http://developer.andro
id.com/sdk/index.html). Es enthält eine Eclipse-IDE sowie alle notwendigen
Android-SDK-Werkzeuge. Arbeiten Sie
bereits mit einer Eclipse-IDE und möch- SDK Setup Wizard zur Installation des SDK-Tools-Pakets (Bild 1)
ten Sie diese weiterverwenden, müssen
die helfen, die Entwicklung von Android-Apps
Sie die Android-spezifischen Tools hinzufügen.
zu vereinfachen und zu beschleunigen. Es bieBeide Wege werden in den folgenden Abschnittet beispielsweise eine grafische Entwicklungsten beschrieben.
umgebung zum Design der Oberflächen oder
Nach dem Download des ADT-Bundles entTools zum einfachen Debuggen der erstellten
packen Sie dieses an einer geeigneten Stelle und
Apps. Was ist nun bei der Installation des Plugrufen nach dem Entpacken die eclipse.exe auf.
ins zu tun?
Dies ist auch schon alles, Sie haben sofort eiDer Download erfolgt direkt aus Eclipse hene lauffähige Entwicklungsumgebung mit alraus (https://dl-ssl.google.com/android/eclipse)
len notwendigen Tools zur Android-App-Ent(Bild 2). Wählen Sie im Folgedialog die Checkwicklung.
box Developer Tools und gehen Sie auf Next. Klicken Sie im nächsten Dialog ebenfalls auf Next
Bestehende Eclipse-IDE
und akzeptieren Sie im abschließenden DiaUm einiges aufwendiger ist es, eine bestehende
log die Lizenzbedingungen, um den Download
Eclipse-Umgebung für die Android-Entwicküber den Finish-Button starten zu können. Starlung »aufzurüsten«. Zunächst laden Sie das
ten Sie Eclipse danach neu. Nach dem Neustart
SDK-Tools-Paket hevon Eclipse wählen Sie im erscheinenden Fensrunter. Es handelt sich
ter Use existing SDKs aus und geben Sie den Ort
dabei um ein ausführdes zuvor installierten Android SDK an.
bares Programm (installer_r21-windows.exe),
das Ihnen bei der Installation der benötigten
Tools hilft (Bild 1). Zuerst wird überprüft, ob
Sie ein JDK installiert haben, anschließend werden die Android-SDK-Tools installiert. Zum Abschluss der Installation wird angeboten, den Android SDK Manager zu öffnen. Starten Sie diesen aber zunächst noch nicht, sondern gehen
Sie direkt zur Installation des Eclipse-Plug-ins
über. Das Eclipse-Plug-in, das sogenannte ADT
(Android Development Tools), stellt verschieEingabe der Daten für eine neue App (Bild 3)
dene Erweiterungen für Eclipse zur Verfügung,
2/2013
MOBILE DEVELOPMENT
Um eine Android-App entwickeln zu können, benötigen Sie nun noch mindestens eine
Android-Plattform und die dazugehörigen SDK
Platform Tools. Starten Sie dazu den SDK Manager unter Window und Android SDK Manager. Beim Start schlägt dieser Ihnen verschiedene
Tools zur Installation vor. Akzeptieren Sie diese
Vorauswahl und wählen Sie nun einfach Install.
Um in Eclipse ein Android-Projekt anzulegen,
wählen Sie aus der Toolbar New und Android Application Project und füllen Sie den erscheinenden Dialog aus (Bild 3). Als Ergebnis hat Eclipse
einige Default-Dateien angelegt, die bereits eine
kleine lauffähige App bilden.
Um Ihre Anwendung auf einem realen Gerät
testen zu können, schließen Sie dieses über eine
USB-Schnittstelle an Ihren Rechner an. Stellen
Sie Ihr Gerät auf USB debugging. Sie finden diese
Einstellung unter Settings, Applications und Development (ältere Geräte) oder unter Settings und
Developer Options (neuere Geräte). Gehen sie in
Ihrem Eclipse-Projekt nun auf run, dann installiert Eclipse Ihre App auf dem Gerät und startet
diese anschließend.
LISTING 1: ACTIVITY_MAIN.XML
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/
android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/text_ersteSeite"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/text_ersteSeite"
android:textColor="@android:color/holo_red_light"
android:textSize="20sp" />
<Button
android:layout_width="132dp"
android:layout_height="wrap_content"
android:layout_marginTop="30dp"
android:background="@android:color/holo_red_light"
android:onClick="redButton"
android:text="@string/button_red" />
<Button
android:layout_width="133dp"
android:layout_height="wrap_content"
android:layout_marginTop="10dp"
android:background="@android:color/holo_green_light"
Auf einem Emulator testen
android:onClick="greenButton"
android:text="@string/button_green" />
</LinearLayout>
Mit dem ADT-Plug-in wird Ihnen auch ein Emulator zum Test der geschriebenen Apps mitgeliefert. Dieser baut das reale Gerät zu Testzwecken in Ihrer Eclipse-Umgebung nach. Der Vorhen können. Sie können die Seite aber auch diteil davon ist, dass Sie so auf einfache Weise Ihrekt in XML definieren und den Layout-Edire App auf verschiedenen Geräten testen köntor dann zum Beispiel als optische Kontrolle
nen. Um einen solchen Emulator verwenden zu
nutzen. Für diese Variante öffnen Sie die Datei
können, müssen Sie jedoch zuerst ein AVD (Anactivity_main.xml aus dem res/layout/-Verzeichdroid Virtual Device) erstellen. Klicken Sie dazu
nis. Sie wurde beim Anlegen des Android-Apin der Toolbar von Éclipse auf den Android Virplication-Projekts erzeugt und enthält ein retual Device Manager (Bild 4). Wählen Sie new und
latives Layout mit einem TextView-Kindobjekt.
geben Sie im anschließenden Formular die DaÄndern Sie nun zuerst das TextView-Objekt, bis
ten für das AVD ein (Bild 5). Nach einem Klick
es dem in Listing 1 entspricht. Sie haben
auf OK erscheint im Android Virtual Device Majetzt eine android:id als eindeutigen Idennager ein neuer Eintrag eines AVD, das Sie zum
tifier, die Höhe und Breite der TextView
Test heranziehen können.
wird durch das Attribut wrap_content so
Zur Veranschaulichung der Programmierung
definiert, dass gerade der Inhalt hineineiner App in Eclipse können Sie im Folgenpasst, der Text wird durch das Attri- ▶
den die Entstehung einer kleinen Beispiel-App verfolgen, in
der auf der Startseite entweder
ein roter oder ein grüner Button gedrückt werden kann und
anschließend auf der Folgeseite
ein entsprechender Text ausgegeben wird.
Beginnen Sie mit dem Design
der Einstiegsseite. Das ADTPlug-in bietet Ihnen die Möglichkeit, einen grafischen Layout-Editor zu nutzen, mit dem
Sie per Drag and Drop Elemente auf die Oberfläche zie- Android Virtual Device Manager (Bild 4) und Eingabeformular zur Erstellung eines neuen AVD (Bild 5)
2/2013
83
MOBILE DEVELOPMENT
Eine neue Android Activity
erstellen (Bild 6)
but text_ersteSeite definiert und die Textfarbe ist Rot.
Anschließend machen Sie aus dem RelativeLayout ein LinearLayout und fügen das
Attribut android:orientation="vertical" hinzu. Jetzt fehlt noch
die Definition der beiden Buttons. Für diese werden wieder die
Breite (layout_width)
und Höhe (layoutheight) definiert. Weiterhin werden der Abstand nach oben (layout-marginTop), die Hintergrundfarbe (background), der Text sowie ein onClick-Element definiert, das die nächste Aktivität aufruft.
Die Texte werden durch Attribute definiert,
die mit dem Typ angegeben werden, in diesem Fall @string, und in einer gesonderten Datei einen Wert zugeordnet bekommen. Es handelt sich dabei um die Datei strings.xml, die unter res/values zu finden ist. Auch hier gibt es wieder die Möglichkeit, die Daten nicht in der XMLDatei, sondern über einen Editor (Resources)
einzugeben, der dann die Eingabe in das XMLFormat umwandelt.
Für die vollständige Funktionalität des kleines Beispielprogramms fehlt nun noch die Reaktion auf den Button-Klick. Fügen Sie dazu in
die Klasse MainActivity die Funktionen redButton und greenButton ein:
verschiedenen Objekten, in diesem Fall Activities, herstellt. Die zweite Aktivität wird dann
einfach gestartet, indem der Methode startActivity der neu erstellte Intent mitgegeben wird.
Es fehlen nun noch die Klassen RedActivity und
GreenActivity. Diese werden in Eclipse erstellt,
indem Sie new und Android Activity auswählen
(Bild 6). Im nächsten Schritt wählen Sie BlankActivity aus und gehen Sie auf Next. Füllen Sie anschließend die Activity-Details aus und drücken
Sie Finish. Eclipse erstellt nun die beiden Klassen sowie die notwendigen Einträge in der Datei AndroidManifest.xml.
Um von der zweiten Aktivität auf die erste
Seite zurückblättern zu können fügen Sie in den
Klassen RedActivity und GreenActivity noch die
folgende Funktion ein:
@Override
public boolean
onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
NavUtils.navigateUpFromSameTask(this);
return true; }
return super.onOptionsItemSelected
(item);
}
Überprüfen Sie auch, ob die Android_Manifest.
xml unter der RedActivity und unter der GreenActivity jeweils den folgenden Eintrag enthält:
<meta-data
android:name="android.support.
PARENT_ACTIVITY"
android:value="com.example.myfirstapp.
public void redButton(View view) {
Devices View mit einem
Prozess, der zum Debug
ausgewählt wurde (Bild 7)
MainActivity" />
Intent intent = new Intent(this,
RedActivity.class);
startActivity(intent);
}
public void
greenButton(View view)
{
Schließlich fehlen für die beiden Activities noch
zwei neue Layouts. Diese können Sie entsprechend der activity_main.xml auch als XML-Datei definieren. Schreiben Sie jeweils eine einfache Seite, die lediglich einen Text ausgibt, welchen Button Sie gedrückt hatten:
Intent intent = new
Intent(this,
<RelativeLayout xmlns:android="http://
GreenActivity.class);
schemas.android.com/apk/res/android"
startActivity(intent);
xmlns:tools="http://schemas.android.
}
com/tools"
android:layout_width="match_parent"
In den beiden Funktionen
wird jeweils ein Intent mit
der Klasse RedActivity beziehungsweise GreenActivity erzeugt, das heißt, mit
der neu zu startenden Activity. Das Intent ist dabei ein
Objekt, das die RuntimeVerbindung zwischen zwei
84
android:layout_height="match_parent"
tools:context=".GreenActivity" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal=
"true"
android:layout_centerVertical="true"
android:text="@string/answer_green" />
2/2013
MOBILE DEVELOPMENT
</RelativeLayout>
Der Text wird dabei wieder in der Datei string.xml
aufgelöst. Sie haben nun
alle Teile der Anwendung
beisammen und können
diese in Eclipse über den
Button run starten.
DDMS
Eclipse arbeitet mit verschiedenen Perspektiven,
die jeweils bestimmte Ansichten zur Darstellung
eines Projekts beinhalten.
Ihre typische Arbeitsperspektive wird die Java perspective sein, für das Debugging gibt es aber die Emulator Control (Bild 8)
DDMS Perspective. Dabei
handelt es sich um verschiedene Ansichten zum
Debugging, von denen einige Wichtige im Folgenden näher erläutert werden:
■ Devices: Die Devices-Ansicht zeigt die laufenden Emulatoren sowie die laufenden Prozesse der Anwendung. Sie ermöglicht durch Anklicken der Symbole in der Kopfzeile verschiedene Debug-Optionen, die anschließend in den
dazugehörigen Views angezeigt werden. Sie
bietet beispielsweise auch die Möglichkeit, einen Prozess zu beenden oder ein Reset der Android Debug Bridge vorzunehmen (Bild 7).
■ Allocation Tracker: Diese Ansicht bietet Einblicke,
wie der Garbage Collector den Speicher Ihrer
App verwaltet.
■ Emulator Control: Das Auswahlfenster Emulator
Control bietet verschiedene Möglichkeiten, das
Verhalten des Emulators im Telefonnetzwerk
zu simulieren (Bild 8).
■ File Explorer: Diese Ansicht bietet Zugriff auf das
Dateisystem des Geräts (Bild 9).
■ Threads: Typischerweise läuft eine AndroidApp in einem einzelnen Prozess. Falls Sie jedoch verschiedene Threads programmiert haben bietet diese Ansicht nähere Informationen
zu den einzelnen Threads.
■ Logcat: Bei dieser View handelt es sich um eine
Log-Konsole zur Ausgabe von Debug-Informationen. Es werden hier vom System generierte
Nachrichten ausgegeben. Sie
können Logcat aber auch für
Ihre persönlichen Log-Ausgaben wie Debug, Info, Warning oder Error verwenden
und diese darauf ausgeben
(Bild 10).
Die Run Configurations bieten Ihnen die Möglichkeit,
2/2013
File Explorer (Bild 9)
verschiedene zusätzliche Optionen zu setzen.
Sie teilen sich in drei Tabs auf: Android, Target
und Common. Unter Android können Sie das Project und die Launch Action auswählen. Der Reiter Target ermöglicht Einstellungen zum Emulator. Sie können zum Beispiel den Punkt always
prompt to pick device auswählen, dann erscheint
beim Start Ihrer Anwendung ein Fenster zur
Auswahl des Emulators. Sie können dann Ihre
App auf den Emulator spielen, was Ihnen den
Neustart des Emulators und somit eine Menge
Zeit erspart. Weiter gibt es auf dem Target-Reiter die Möglichkeit, Command Line Options für
den Emulator einzufügen.
Fazit
Der Workshop hat Ihnen eine Einführung in die
Android-App-Entwicklung gegeben. Sie haben
gesehen, welche Tools installiert werden müssen und wie Sie ein Android-Projekt in Eclipse
anlegen. Anhand der kleinen Beispiel-App haben Sie Grundlagen der Entwicklung in Eclipse erfahren und den Emulator kennengelernt.
Schließlich zeigte Ihnen der letzte Abschnitt verschiedene Informationen zum Debugging sowie
zu Einstellungen, die das Abspielen der App
betreffen. Weiterführende Informationen finden
Sie auf den Android-Entwicklerseiten.
[mb]
Logcat mit DebugAusgaben (Bild 10)
85