Android DER SCHNELLE UND EINFACHE EINSTIEG IN DIE PROGRAMMIERUNG UND ENTWICKLUNGSUMGEBUNG. Dirk Louis»Android«Jetzt bei. EXTRA: Mit kostenlosem E-Book

dirk LOUIS peter MÜLLER Dirk Louis»Android«Jetzt bei Android DER SCHNELLE UND EINFACHE EINSTIEG IN DIE PROGRAMMIERUNG UND ENTWICKLUNGSUMGEBUNG EXTRA: Mit kostenlosem E-Book Auf DVD: Beispiele, Tutorials, JRE und Android-Bundle Inklusive: Java-Tutorium für Ein- und Umsteiger

Inhalt Vorwort.................................................... XV Teil I: Einführung............................................ 1 1 Der Rechner wird vorbereitet............................... 3 1.1 Die nötigen Hilfsmittel................................................ 3 1.2 Installation des Android-ADT-Bundle.................................... 4 1.3 Eclipse............................................................. 6 1.3.1 Erster Start................................................... 6 1.3.2 Desktop-Verknüpfung anlegen................................... 8 1.4 Die JRE für Java...................................................... 8 1.5 Der Android-SDK-Manager............................................. 9 1.5.1 Die Android-Versionen.......................................... 9 1.5.2 APIs und SDKs nachinstallieren.................................. 10 1.5.3 Dokumentation und API-Referenz................................ 12 1.6 Wo Sie weitere Hilfe finden............................................ 14 1.7 Nächste Schritte..................................................... 14 1.8 Fragen und Antworten................................................ 15 1.9 Übungen............................................................ 15 2 Auf die Plätze, fertig... App!............................... 17 2.1 Die Ruhe vor dem Sturm.............................................. 17 2.2 Das Projekt.......................................................... 18 2.3 Das vorgegebene Codegerüst........................................... 27 2.3.1 Die package-anweisung......................................... 28 2.3.2 Die import-anweisungen........................................ 29 2.3.3 Die Klassendefinition........................................... 30 2.4 Layout und Ressourcen................................................ 31 2.4.1 XML-Layouts.................................................. 32 2.4.2 Ressourcen................................................... 34

VI Inhalt 2.5 Die App erstellen (Build).............................................. 36 2.6 Die App im Emulator testen............................................ 37 2.6.1 AVD für Emulator anlegen....................................... 37 2.6.2 App testen.................................................... 40 2.7 Die App auf dem Smartphone oder Tablet-PC testen........................ 42 2.8 Nächste Schritte..................................................... 45 2.9 Fragen und Antworten................................................ 45 2.10 Übungen............................................................ 46 3 Was wann wofür......................................... 47 3.1 Was ist zu tun? Die drei Pfeiler der App-Erstellung........................ 47 3.2 Wer hilft uns? Bausteine und Klassen.................................. 48 3.2.1 Bausteine für den App-Aufbau................................... 48 3.2.2 Klassen zur Adressierung spezieller Aufgaben..................... 52 3.3 Wo wird was gespeichert? Dateitypen, die Sie kennen sollten.............. 53 3.3.1 Quelldateien.................................................. 53 3.3.2 Automatisch generierte Dateien.................................. 54 3.3.3 Die Android-Bibliothek......................................... 55 3.3.4 assets........................................................ 56 3.3.5 Die Ressourcendateien.......................................... 56 3.3.6 Die Manifestdatei.............................................. 56 3.3.7 Die Properties-Datei............................................ 58 3.3.8 Die APK-Datei................................................. 59 3.4 Fragen und Antworten................................................ 59 3.5 Übung.............................................................. 60 Teil II: Grundlagen........................................... 61 4 Code................................................... 63 4.1 Unterstützung durch den Eclipse-Editor.................................. 63 4.1.1 Syntaxhervorhebung........................................... 64 4.1.2 Gliederung (Folding)........................................... 64 4.1.3 QuickFix..................................................... 66 4.1.4 QuickInfo statt API-Dokumentation............................... 70 4.1.5 Klammerpaare identifizieren.................................... 73 4.1.6 Zeilennummern einblenden..................................... 73 4.1.7 Alle Vorkommen markieren..................................... 74 4.1.8 Definitionen finden............................................ 74 4.1.9 Code erweitern................................................ 75 4.1.10 Refactoring (Code umstrukturieren).............................. 77 4.2 Klassen in eigene Quelldateien auslagern................................. 79 4.2.1 Die Tuschstaffel-App........................................... 79 4.2.2 Quelldateien hinzufügen........................................ 83

Inhalt VII 4.3 Fragen und Antworten................................................ 85 4.4 Übung.............................................................. 85 5 Die Benutzeroberfläche (Layout)........................... 87 5.1 Ein paar einführende Gedanken zum Design von Benutzeroberflächen........ 87 5.2 Die zwei Gesichter der Layoutdateien: XML kontra Designer................ 90 5.2.1 Der XML-Code................................................. 91 5.2.2 Der Designer.................................................. 96 5.3 Layout-Views........................................................ 99 5.3.1 Die allgemeinen Layoutparameter................................ 100 5.3.2 Die Layout-Views.............................................. 103 5.3.3 Hintergrundfarbe (oder -bild).................................... 111 5.3.4 Hierarchy Viewer.............................................. 114 5.4 Widgets............................................................. 115 5.5 Praxisbeispiel: eine Quiz-Oberfläche..................................... 119 5.6 Hoch- und Querformat................................................ 123 5.7 App-Symbol......................................................... 125 5.8 Views im Code verwenden............................................. 126 5.8.1 Layouts laden................................................. 126 5.8.2 Zugriff auf UI-Elemente......................................... 127 5.9 Fragen und Antworten................................................ 128 5.10 Übung.............................................................. 129 6 Ressourcen............................................. 131 6.1 Der grundlegende Umgang............................................ 131 6.1.1 Ressourcen anlegen............................................ 132 6.1.2 Ressourcen verwenden......................................... 135 6.1.3 Ressourcen aus dem Projekt entfernen............................ 138 6.2 Welche Arten von Ressourcen gibt es?................................... 139 6.2.1 Größenangaben............................................... 139 6.2.2 Farben....................................................... 140 6.2.3 Strings....................................................... 141 6.2.4 String-Arrays (Texte)........................................... 142 6.2.5 Bilder........................................................ 145 6.2.6 Layouts...................................................... 146 6.2.7 Menüs....................................................... 146 6.2.8 Roh- und Multimediadaten...................................... 147 6.2.9 Stile......................................................... 148 6.3 Alternative Ressourcen vorsehen....................................... 152 6.3.1 Das Grundprinzip.............................................. 152 6.3.2 Wie stellt man konfigurationsspezifische Ressourcen bereit?.......... 154 6.4 Fragen und Antworten................................................ 155 6.5 Übungen............................................................ 156

VIII Inhalt 7 Mit dem Anwender interagieren............................ 157 7.1 Das Grundprinzip.................................................... 157 7.1.1 Auf ein Ereignis reagieren...................................... 158 7.1.2 Welche Ereignisse gibt es?...................................... 161 7.1.3 Hintergrund der Ereignisverarbeitung............................ 162 7.2 Vereinfachte Ereignisbehandlung....................................... 164 7.2.1 Ereignisbehandlung mit anonymen Listener-Klassen................ 164 7.2.2 Ereignisbehandlung mit anonymen Listener-Objekten............... 165 7.2.3 Ereignisbehandlung mithilfe der Activity-Klasse.................... 166 7.3 Eine Behandlungsmethode für mehrere Views............................ 166 7.4 Auf Tipp- und Wischereignisse reagieren................................ 168 7.4.1 Tippereignisse................................................ 168 7.4.2 Wischereignisse............................................... 169 7.5 Auf Tastendrücke reagieren............................................ 171 7.6 Ereignisverarbeitung in selbst geschriebenen View-Klassen................. 172 7.7 Fragen und Antworten................................................ 173 7.8 Übungen............................................................ 174 8 App-Grundlagen und Lebenszyklus......................... 175 8.1 Die Android-Architektur............................................... 175 8.2 Der App-Lebenszyklus................................................ 177 8.3 Der Activity-Lebenszyklus............................................. 179 8.4 Lebenszyklusdemo................................................... 181 8.5 Fragen und Antworten................................................ 185 8.6 Übung.............................................................. 186 Teil III: Weiterführende Themen................................ 187 9 In Views zeichnen........................................ 189 9.1 Das Grundprinzip.................................................... 189 9.1.1 Die Leinwand................................................. 189 9.1.2 Das Atelier.................................................... 189 9.1.3 Die Zeichenmethoden und -werkzeuge............................ 190 9.1.4 Wie alles zusammenwirkt....................................... 190 9.2 Grafikprimitive zeichnen.............................................. 194 9.3 Bilder bewegen...................................................... 197 9.4 Verbesserungen...................................................... 202 9.5 Fragen und Antworten................................................ 203 9.6 Übung.............................................................. 203 10 Menüs und Dialoge....................................... 205 10.1 Menüs.............................................................. 205

Inhalt IX 10.1.1 Menüverwirrungen............................................ 206 10.1.2 Menüressourcen............................................... 207 10.1.3 Menüeinträge in der ActionBar.................................. 210 10.1.4 Das Optionen-Menü............................................ 211 10.1.5 Das Kontextmenü.............................................. 212 10.1.6 Popup-Menü.................................................. 214 10.1.7 Untermenüs.................................................. 214 10.1.8 Auf die Auswahl eines Menüeintrags reagieren..................... 215 10.2 Dialoge............................................................. 217 10.2.1 Dialoge erzeugen.............................................. 218 10.2.2 Dialoge anzeigen.............................................. 218 10.2.3 Standarddialoge mit AlertDialog................................. 219 10.2.4 Dialoge für Datum- und Zeitauswahl.............................. 221 10.2.5 Der Fortschrittsdialog.......................................... 223 10.2.6 Eigene Dialoge definieren....................................... 225 10.3 Benachrichtigungen mit Toasts......................................... 227 10.3.1 Toasts im Hintergrund-Thread................................... 227 10.4 Fragen und Antworten................................................ 228 10.5 Übungen............................................................ 229 11 Mehrseitige Apps........................................ 231 11.1 Intents............................................................. 231 11.1.1 Was sind Intents?.............................................. 232 11.1.2 Explizite und implizite Intents................................... 233 11.1.3 Intent-Filter................................................... 233 11.2 Activities starten mit Intents........................................... 234 11.2.1 Intent-Objekte erzeugen........................................ 235 11.3 Intents empfangen................................................... 237 11.4 Ein Demo-Beispiel.................................................... 237 11.5 Ergebnisse zurücksenden............................................. 240 11.6 Fragen und Antworten................................................ 241 11.7 Übung.............................................................. 241 12 Daten speichern......................................... 243 12.1 Preferences......................................................... 243 12.2 Dateizugriffe........................................................ 244 12.2.1 In Dateien schreiben........................................... 244 12.2.2 Aus Dateien lesen.............................................. 245 12.2.3 Textdateien................................................... 246 12.2.4 Welche Dateien sind vorhanden?................................. 247 12.2.5 Dateien als Ressourcen verwalten................................ 248 12.3 Zugriff auf die SD-Karte............................................... 248 12.4 Die Reaktions-App.................................................... 250

X Inhalt 12.5 Fragen und Antworten............................................... 255 12.6 Übungen.......................................................... 255 13 Quiz-Apps.............................................. 257 13.1 Aufbau und Benutzeroberfläche....................................... 257 13.2 Die Activity (QuizActivity.java)........................................ 258 13.3 Die Fragen (Frage.java).............................................. 260 13.4 Die Spielsteuerung (Spiellogik.java).................................... 261 13.5 Verbesserungen.................................................... 263 13.6 Fragen und Antworten............................................... 264 13.7 Übung............................................................ 264 14 Multimedia............................................ 265 14.1 Audioressourcen.................................................... 265 14.2 Soundeffekte mit SoundPool.......................................... 266 14.3 Das Universalgenie: MediaPlayer...................................... 268 14.3.1 Audioressourcen abspielen.................................... 268 14.3.2 Audiodateien vom Dateisystem abspielen........................ 269 14.3.3 Audiodateien aus dem Internet abspielen........................ 269 14.3.4 Auf das Abspielende reagieren................................. 270 14.3.5 MediaPlayer-Objekte wiederverwenden......................... 271 14.3.6 Ressourcen freigeben........................................ 273 14.3.7 Audiodateien wiederholt abspielen............................. 274 14.4 Piepen und andere Töne............................................. 274 14.5 Bilddateien anzeigen................................................ 276 14.6 Videos abspielen.................................................... 277 14.7 Videos aufnehmen.................................................. 278 14.8 Fotos aufnehmen und speichern....................................... 279 14.9 Fragen und Antworten............................................... 284 14.10 Übungen.......................................................... 284 15 Sensoren.............................................. 285 15.1 Zugriff............................................................ 285 15.1.1 Was Sie benötigen........................................... 286 15.1.2 Welche Sensoren sind verfügbar?.............................. 286 15.1.3 Anmeldung beim Sensor...................................... 287 15.2 Sensordaten auslesen................................................ 289 15.2.1 Beschleunigungswerte ermitteln............................... 291 15.2.2 Lagedaten ermitteln.......................................... 294 15.3 Fragen und Antworten............................................... 298 15.4 Übung............................................................ 299

Inhalt XI 16 Einsatz der Datenbank SQLite............................ 301 16.1 Was ist eine relationale Datenbank?.................................... 301 16.2 Datenbank anlegen/öffnen........................................... 302 16.2.1 oncreate().................................................. 303 16.2.2 onupgrade()................................................ 305 16.2.3 close()..................................................... 305 16.2.4 Datenbanken als Ressourcen mitgeben.......................... 305 16.3 Datenzugriffe....................................................... 306 16.4 Datenbankinhalte mit ListView anzeigen............................... 311 16.5 Fragen und Antworten............................................... 315 16.6 Übung............................................................ 315 17 Geolokation............................................ 317 17.1 Zugriff............................................................ 317 17.1.1 Verfügbarkeit feststellen...................................... 317 17.1.2 Daten empfangen............................................ 318 17.1.3 Empfänger abmelden......................................... 319 17.2 Geokoordinaten..................................................... 320 17.2.1 Sexagesimale und dezimale Darstellung......................... 320 17.2.2 Das Location-Objekt.......................................... 320 17.3 Die Demo-App...................................................... 322 17.4 Fragen und Antworten............................................... 326 17.5 Übung............................................................ 326 18 Brettspiel-Apps (TicTacToe)............................... 327 18.1 Aufbau und Benutzeroberfläche....................................... 327 18.2 Die Start-Activity (TicTacToeActivity)................................... 329 18.3 Spielfeld und Logik (TicTacToeView)................................... 330 18.3.1 Vorbereitungen.............................................. 330 18.3.2 Spielfeld zeichnen........................................... 331 18.3.3 Spielerzug durchführen....................................... 333 18.3.4 Computerzug mit AsyncTask durchführen....................... 334 18.4 Verbesserungen.................................................... 336 18.5 Fragen und Antworten............................................... 337 18.6 Übung............................................................ 337 19 Tablet-Unterstützung mit Fragmenten...................... 339 19.1 19.2 19.3 19.4 Was ist ein Fragment?............................................... 339 Ein Fragment erzeugen.............................................. 340 Fragment zur Activity hinzufügen..................................... 340 Ein Fragmentbeispiel................................................ 342 19.4.1 Das Layout der Activity....................................... 343

XII Inhalt 19.4.2 Definition der Fragment-Klassen............................... 344 19.4.3 Die Activity................................................. 346 19.5 Fragmente für Dialoge............................................... 349 19.6 Fragen und Antworten............................................... 350 19.7 Übung............................................................ 351 20 Tipps und Tricks........................................ 353 20.1 Mehrere AVDs und Emulator- Konfigurationen einrichten.................. 353 20.2 Das Smartphone vibrieren lassen...................................... 356 20.3 UI-Code periodisch ausführen lassen................................... 357 20.4 Bildergalerien mit GridView und BaseAdapter........................... 360 20.4.1 Die Bildressourcen........................................... 361 20.4.2 Die Adapter-Klasse........................................... 361 20.4.3 Die GridView............................................... 364 20.4.4 Angeklickte Bilder als Vollbild anzeigen......................... 365 20.5 Spinner verwenden (Listenfelder)...................................... 367 20.5.1 Den Spinner mit Daten füllen.................................. 368 20.5.2 Ereignisbehandlung.......................................... 369 20.6 Mehrsprachige Apps................................................ 370 20.7 Fragen und Antworten............................................... 372 20.8 Übung............................................................ 373 Anhang A: Apps veröffentlichen oder weitergeben................ 375 A.1 A.2 A.3 A.4 A.5 A.6 Die App vorbereiten................................................. 375 Digitales Signieren.................................................. 377 Die App exportieren und signieren..................................... 377 Bei Google Play registrieren.......................................... 380 A.4.1 Steuerliche Aspekte bei App-Verkauf............................ 381 App hochladen..................................................... 382 Weitergabe an Bekannte............................................. 382 Anhang B: Eclipse............................................ 385 B.1 Android-Projekt anlegen............................................. 385 B.2 Projekte erstellen................................................... 385 B.3 Projekte deaktivieren................................................ 387 B.4 Projekte löschen.................................................... 387 B.5 Neuen Workspace einrichten.......................................... 388 B.6 Bestehendes Projekt in Workspace a ufnehmen (Import)................... 389 B.7 Launch-Konfigurationen anpassen oder einrichten....................... 390 B.8 Properties-Fenster anzeigen.......................................... 391 B.9 Formatierung von XML-Layoutdateien.................................. 392

Inhalt XIII B.10 Apps exportieren................................................... 393 B.11 Kleines Eclipse-Wörterbuch........................................... 393 Anhang C: Emulator, DDMS & Debugger......................... 395 C.1 Der Emulator....................................................... 395 C.1.1 AVD-Dateien................................................ 396 C.1.2 Emulator starten............................................ 398 C.1.3 Die Emulator-Bedienung...................................... 403 C.1.4 Apps installieren und deinstallieren............................ 404 C.2 Das DDMS......................................................... 404 C.3 Der Debugger...................................................... 409 C.3.1 Debug-Lauf starten........................................... 409 C.3.2 Debug-Möglichkeiten......................................... 411 C.4 Debugging-Beispiel.................................................. 414 Anhang D: Die DVD zum Buch.................................. 419 Anhang E: Lösungen......................................... 423 Anhang F: Glossar........................................... 439 Index...................................................... 449

1 Der Rechner wird vorbereitet Bevor Sie mit der App-Programmierung beginnen können, müssen Sie sicherstellen, dass Sie das nötige Arbeitsgerät zur Verfügung haben. Die gute Nachricht ist: Alles, was Sie zum Schreiben eigener Apps benötigen, gibt es kostenlos auf der Buch-DVD (oder alternativ im Internet). Die weniger gute Nachricht ist: Sie müssen die nötigen Entwicklungswerkzeuge erst einmal installieren, konfigurieren und siehe nächstes Kapitel testen. Aber wie sagt schon ein auf Seneca zurückgehendes Sprichwort: per aspera ad astra ( Durch Mühsal zu den Sternen oder wie es in Anlehnung an Hesiod heißt: Vor den Erfolg haben die Götter den Schweiß gestellt. ) 1.1 Die nötigen Hilfsmittel Um Apps schreiben zu können, benötigen Sie: das Android-SDK Das Android-SDK1 enthält alle wichtigen Tools, Bibliotheken und Dokumentationen, die für die Erstellung von Android-Apps benötigt werden. Das Android-SDK wird zusammen mit dem Android-Bundle installiert. Wir werden es allerdings im Nachhinein noch etwas anpassen. Eclipse mit dem Android-Plug-in (optional, aber empfehlenswert) Für die Programmierung werden in der Regel viele spezialisierte Hilfsprogramme benötigt, beispielsweise ein Editor zum Aufsetzen der Programmquelltexte, ein Compiler zum Übersetzen der Quelltexte in Programmcode, ein Debugger zur schrittweisen Ausführung von Programmen zwecks Fehleranalyse, um nur die wichtigsten Helfer zu nennen. In integrierten Entwicklungsumgebungen (kurz IDEs) werden diese Hilfsprogramme in einem übergeordneten Programm zusammengefasst. Dies erleichtert die Arbeit, erspart dem Programmierer ständige Wechsel zwischen den Anwendungen und erlaubt zudem 1 SDK steht für Software Development Kit, grob übersetzt also ein Bausatz zur Entwicklung von Software.

4 1 Der Rechner wird vorbereitet eine intensivere Zusammenarbeit der eingesetzten Hilfsprogramme (wie z. B. die Zuordnung von Compiler-Fehlermeldungen zu Quelltextzeilen oder die Anzeige der aktuellen Ausführungsposition beim Debuggen im Editor). Eclipse ist eine solche integrierte Entwicklungsumgebung und kann durch Installation des Android-Plug-ins für die Erstellung von Android-Apps eingerichtet werden. Eclipse und das Android-Plug-in werden ebenfalls zusammen mit dem Android-Bundle installiert (wobei es kein Problem ist, die Eclipse-Installation für Android parallel zu einer bereits vorhandenen Eclipse-Installation zu betreiben). Beim ersten Start von Eclipse wird das Programm noch ein wenig angepasst. die JRE für Java Zum Ausführen von Eclipse wird die Java-Laufzeitumgebung, die sogenannte JRE (Java Runtime Environment), benötigt. Die JRE wird nicht zusammen mit dem Android-ADT-Bundle installiert, da sie auf vielen Rechnern bereits vorhanden ist. Sollte auf Ihrem Rechner noch keine JRE-Version installiert sein, müssen Sie dies nachholen. ein Android-Smartphone (optional) und natürlich einen nicht zu alten Rechner mit mindestens 700 Mbyte freiem Festplattenspeicher (optimal wären 2 bis 3 Gbyte) und einem geeigneten Betriebssystem (unseres Wissens nach eignet sich jedes nicht zu alte Windows-, MacOS- oder Linux-System) Spaß am Programmieren, Ausdauer und auch ein bisschen Mut DVD ZUM BUCH Auf der Buch-DVD finden Sie das Android-ADT-Bundle und falls benötigt auch die Java-JRE. Wir hätten gerne noch ein kostenloses Android-Smartphone hinzugepackt, aber es ließ sich leider kein Sponsor finden. 1.2 Installation des Android-ADT-Bundle Es gibt verschiedene Möglichkeiten, eine Android-Entwicklungsumgebung einzurichten: Sie können das Android-ADT-Bundle installieren, welches eine komplette Android-Entwicklungsumgebung inklusive passender Eclipse-IDE einrichtet. Sie können mithilfe der SDK-Tools eine bereits installierte Entwicklungsumgebung (z. B. Eclipse) für die Android-Programmierung nutzbar machen. Demnächst wird es auch eine eigens von Google für die Android-Programmierung entwickelte Android-IDE geben. Bis diese in einer stabilen und verlässlichen Version vorliegt, dürfte allerdings noch etwas Zeit vergehen.

1.2 Installation des Android-ADT-Bundle 5 Wir empfehlen, das Android-ADT-Bundle zu installieren. Auf diese Weise gibt es am wenigsten Schwierigkeiten bei der Installation. Und keine Angst, falls Sie bereits mit Eclipse arbeiten: Sie können problemlos mehrere Eclipse-Installationen parallel betreiben. Sie sollten nur vielleicht darauf achten, für jede Installation einen eigenen Workspace zu betreiben (siehe Abschnitt 1.3.1). Außerdem empfehlen wir Ihnen, das Android-ADT-Bundle zu installieren, welches wir Ihnen auf die Buch-DVD gepackt haben. Sie arbeiten dann vielleicht nicht unbedingt mit der allerneuesten Android-Version, aber dafür stimmt die Umgebung auf Ihrem Rechner weitest möglich mit der Beschreibung im Buch zusammen. 1. Suchen Sie auf der Buch-DVD nach der zu Ihrem System passenden ADT-Bundle-Datei. Im Unterverzeichnis Android_Bundle finden Sie drei Unterverzeichnisse für die verschiedenen Betriebssysteme Windows, Linux und Mac OS. Windows- und Linux-Anwender müssen zudem die zu ihrem System passende ZIP-Datei wählen. Für 32-Bit-Systeme wäre dies die ZIP-Datei mit der Angabe x86 im Namen, während Sie für 64-Bit-Systeme die ZIP-Datei mit der Angabe x86_64 verwenden. 32- ODER 64-BIT Sie sind unsicher, ob Sie über einen 32-Bit- oder 64-Bit-Rechner verfügen? Wenn es sich um einen Windows-Rechner handelt, rufen Sie die Systemsteuerung auf, schalten Sie die Anzeige ggf. auf Kleine Symbole und klicken Sie auf System. Auf der erscheinenden Seite werden Ihnen Betriebssystem- und Prozessortyp angezeigt. 2. Extrahieren Sie die ADT-Bundle-Datei in ein Verzeichnis Ihrer Wahl, wie z. B. C:\ oder C:\ Android. Die extrahierten Dateien stehen dann automatisch in einem Unterverzeichnis C:\<name_der_bundle_datei> bzw. C:\ Android\<name_der_bundle_datei>. Sie können zum Extrahieren jedes geeignete ZIP-Programm verwenden (einschließlich des Windows Explorers von Windows, ab Version 7). Achten Sie aber darauf, dass die in der ZIP-Datei enthaltenen Dateien unter Berücksichtigung der Pfadangaben extrahiert werden. TIPP: Wenn Sie möchten, können Sie den Verzeichnisnamen <name_der_bundle_datei> nachträglich ändern. Das war s. Na ja, fast. Sie haben Ihre Buch-DVD verloren oder möchten doch lieber die Installation mit den SDK-Tools versuchen? Auf der Android-Website http://developer.android.com/ sdk/index.html finden Sie alle benötigten Installationsdateien und Anleitungen.

6 1 Der Rechner wird vorbereitet 1.3 Eclipse Nachdem Sie das Android-ADT-Bundle extrahiert haben, sollten Sie Eclipse einmal probeweise starten zum einen, um zu testen, ob alles korrekt installiert wurde, zum andern, um Eclipse weiter zu konfigurieren. Eclipse ist unter professionellen Programmierern recht beliebt, denn Eclipse ist kostenfrei (für viele Unternehmen und Programmierer das wichtigste Argument überhaupt), recht leistungsstark und vor allem sehr flexibel. Die Arbeit mit Eclipse und dem Android-Plug-in ist allerdings nicht immer so intuitiv und einfach, wie man sich dies, vor allem als Programmierneuling oder Umsteiger von anderen Entwicklungsumgebungen, wünschen würde. Wir werden daher gerade in den ersten Kapiteln nebenbei auch des Öfteren auf die Arbeit mit Eclipse eingehen. Der Aufwand lohnt sich allemal, denn die Alternative Android-Programmierung mit dem reinen Android-SDK birgt noch weitaus mehr Tücken. Die wichtigsten Arbeitsschritte mit Eclipse haben wir überdies für Sie noch einmal im Anhang zusammengefasst! 1.3.1 Erster Start 1. Wechseln Sie im Windows Explorer ((WinBef)+(E)) in das Verzeichnis Ihrer AndroidInstallation (siehe Schritt 2 im Abschnitt 1.2) und dann in das Unterverzeichnis eclipse. 2. Doppelklicken Sie auf die Datei eclipse.exe (bzw. eclipse, falls der Windows Explorer so konfiguriert ist, dass er keine Dateierweiterungen anzeigt), um Eclipse zu starten. ACHTUNG Falls eine Fehlermeldung erscheint, dass keine JRE- oder JDK-Installation gefunden werden konnte, brechen Sie an dieser Stelle ab, installieren Sie die JRE wie in Abschnitt 1.4 beschrieben und kehren Sie dann wieder hierher zurück. Wenn Sie Eclipse das erste Mal starten, erscheint ein Dialogfeld, welches Sie nach dem zu verwendenden Workspace-Verzeichnis fragt. Die Vorgabe ist üblicherweise ein Verzeichnis namens workspace, das unter Ihrem Benutzerverzeichnis (unter Windows 8: C:\ Users\<Benutzername>) angelegt wird. 3. Ersetzen Sie den vorgegebenen Pfad durch C:\MeineApps und aktivieren Sie die Option Use this as the default..., um nicht bei jedem Start von Eclipse nach dem WorkspaceVerzeichnis gefragt zu werden. 4. Klicken Sie auf OK.

1.3 Eclipse 7 Bild 1.1 Das Arbeitsverzeichnis wird festgelegt. WORKSPACE (ARBEITSVERZEICHNIS) In Eclipse werden Programme (inklusive Apps), an denen Sie arbeiten, in Form von Projekten verwaltet. Dabei werden alle Dateien, die zu einem Projekt gehören (wie Quelltextdateien, Bilddateien etc.), in einem eigenen Verzeichnis abgelegt, dem sogenannten Projektverzeichnis, welches Sie angeben, wenn Sie ein neues Projekt anlegen. Die Projekte, die Sie anlegen, werden selbst wieder in übergeordneten Arbeitsverzeichnissen, den sogenannten workspaces, abgelegt. Wenn Sie den Workspace wie oben beschrieben beim ersten Start von Eclipse festlegen, werden alle Projekte, die Sie später anlegen, unter diesem Workspace abgelegt. Wenn Sie wieder beim Start von Eclipse nach dem zu verwendenden Workspace gefragt werden möchten, rufen Sie in Eclipse den Befehl Window/Preferences auf, wechseln Sie zur Seite General, Startup and Shutdown/Workspaces und aktivieren Sie die Option Refresh workspace on startup. 5. Schließen Sie die Begrüßungsseite Android IDE. 6. Werfen Sie einen ersten Blick auf die Eclipse-IDE und schließen Sie danach das Programm. Englischkenntnisse sind für die Arbeit mit der englischsprachigen Eclipse-IDE hilfreich. Eine Umstellung der IDE auf Deutsch ist unseres Wissens derzeit nicht möglich. (Vielleicht möchten Sie ja ein entsprechendes Plug-in schreiben?) Für Leser, die mit der englischen Fachterminologie noch nicht so vertraut sind, haben wir daher im Anhang ein kleines Wörterbuch zusammengestellt.