Titelei
Impressum
Inhalt
Vorwort
Teil I Einführung
1 Der Rechner wird vorbereitet
1.1 Die nötigen Hilfsmittel
1.2 Installation des JDK
1.3 Installation von Android Studio
1.3.1 Erster Start
1.4 Der Android-SDK-Manager
1.4.1 Die Android-Versionen
1.4.2 APIs/SDKs und anderes nachinstallieren
1.4.3 Dokumentation und API-Referenz
1.5 Wo Sie weitere Hilfe finden
1.6 Nächste Schritte
1.7 Frage und Antworten
1.8 Übungen
2 Auf die Plätze, fertig … App!
2.1 Die Ruhe vor dem Sturm
2.2 Das Projekt
2.3 Das vorgegebene Codegerüst
2.3.1 Die package-Anweisung
2.3.2 Die import-Anweisungen
2.3.3 Die Klassendefinition
2.4 Layout und Ressourcen
2.4.1 XML-Layouts
2.4.2 Ressourcen
2.5 Die App bauen (Build)
2.6 Die App im Emulator testen
2.6.1 AVD für Emulator anlegen
2.6.2 Die App testen
2.7 Die App auf Smartphone oder Tablet testen
2.8 Nächste Schritte
2.9 Fragen und Antworten
2.10 Übungen
3 Was wann wofür
3.1 Was ist zu tun? ‒ Die drei Pfeiler der App-Erstellung
3.2 Wer hilft uns? ‒ Bausteine und Klassen
3.2.1 Bausteine für den App-Aufbau
3.2.2 Klassen zur Adressierung spezieller Aufgaben
3.3 Wo wird was gespeichert? ‒ Dateitypen, die Sie kennen sollten
3.3.1 Quelldateien
3.3.2 Die Datei R.java
3.3.3 Assets
3.3.4 Die Ressourcendateien
3.3.5 Die Manifestdatei AndroidManifest.xml
3.3.6 Die APK-Datei
3.4 Frage und Antworten
3.5 Übung
Teil II Grundlagen
4 Code
4.1 Der Editor
4.1.1 Syntaxhervorhebung
4.1.2 Code Folding (Code-Gliederung)
4.1.3 Code Completion (Code-Vervollständigung)
4.1.4 Syntaxfehler beheben
4.1.5 Informationen über Klassen und Methoden
4.1.6 Klammerpaare identifizieren
4.1.7 Zeilennummern einblenden
4.1.8 Code generieren
4.1.9 Refactoring (Code umstrukturieren)
4.1.10 Dateiverlauf (Local History)
4.2 Neue Klassen anlegen
4.3 Fragen und Antworten
4.4 Übungen
5 Benutzeroberfläche und Layout
5.1 Einführung
5.2 Der Layout-Designer
5.2.1 Die Text-Ansicht (XML-Code)
5.2.2 Die Design-Ansicht
5.3 Layouts (ViewGroups)
5.3.1 Die allgemeinen Layoutparameter
5.3.2 ViewGroups
5.3.3 Hintergrundfarbe (oder -bild)
5.3.4 Der Hierarchy Viewer
5.4 UI-Elemente
5.5 Richtlinien für das Design von Benutzeroberflächen
5.6 Praxisbeispiel: eine Quiz-Oberfläche
5.7 Hoch- und Querformat
5.8 Das App-Symbol
5.9 Views im Code verwenden
5.9.1 Layouts laden
5.9.2 Zugriff auf UI-Elemente
5.10 Fragen und Antworten
5.11 Übung
6 Ressourcen
6.1 Der grundlegende Umgang
6.1.1 Ressourcen anlegen
6.1.2 Ressourcen verwenden
6.1.3 Ressourcen aus dem Projekt entfernen
6.2 Welche Arten von Ressourcen gibt es?
6.2.1 Größenangaben
6.2.2 Farben
6.2.3 Strings
6.2.4 Strings in mehreren Sprachen (Lokalisierung)
6.2.5 Bilder
6.2.6 Layouts
6.2.7 Menüs
6.2.8 Roh- und Multimediadaten
6.2.9 Stile
6.3 Alternative Ressourcen vorsehen
6.3.1 Das Grundprinzip
6.3.2 Wie stellt man konfigurationsspezifische Ressourcen bereit?
6.4 Fragen und Antworten
6.5 Übungen
7 Mit dem Anwender interagieren
7.1 Das Grundprinzip
7.1.1 Auf ein Ereignis reagieren
7.1.2 Welche Ereignisse gibt es?
7.1.3 Hintergrund der Ereignisverarbeitung
7.2 Vereinfachte Ereignisbehandlung
7.2.1 Ereignisbehandlung mit anonymen Listener-Klassen
7.2.2 Ereignisbehandlung mit anonymen Listener-Objekten
7.2.3 Ereignisbehandlung mithilfe der Activity-Klasse
7.3 Eine Behandlungsmethode für mehrere Views
7.4 Auf Tipp- und Wischereignisse reagieren
7.4.1 Tippereignisse
7.4.2 Wischereignisse
7.5 Multi-Touch und Gesten erkennen
7.5.1 Multi-Touch
7.5.2 Gestenerkennung
7.6 Frage und Antworten
7.7 Übung
8 App-Grundlagen und Lebenszyklus
8.1 Die Android-Architektur
8.2 Der App-Lebenszyklus
8.3 Der Activity-Lebenszyklus
8.4 Lebenszyklusdemo
8.5 Fragen und Antworten
8.6 Übung
Teil III Weiterführende Themen
9 In Views zeichnen
9.1 Das Grundprinzip
9.1.1 Die Leinwand
9.1.2 Das Atelier
9.1.3 Die Zeichenmethoden und -werkzeuge
9.1.4 Wie alles zusammenwirkt
9.2 Grafikprimitive zeichnen
9.3 Bilder laden
9.4 In Bilder hineinzeichnen
9.5 Bilder bewegen
9.6 Verbesserungen
9.7 Fragen und Antworten
9.8 Übung
10 Menüs, Fragmente und Dialoge
10.1 Menüs
10.1.1 Menüverwirrungen
10.1.2 Menüressourcen
10.1.3 Menüeinträge in der ActionBar (AppBar)
10.1.4 Das Optionen-Menü
10.1.5 Das Kontextmenü
10.1.6 Popup-Menü
10.1.7 Untermenüs
10.1.8 Auf die Auswahl eines Menüeintrags reagieren
10.2 Fragmente
10.2.1 Was ist ein Fragment?
10.2.2 Ein Fragment erzeugen
10.2.3 Fragment zur Activity hinzufügen
10.2.4 Ein Fragmentbeispiel
10.2.5 Definition der Fragment-Klassen
10.2.6 Die Activity
10.3 Dialoge
10.3.1 Dialoge erzeugen
10.3.2 Dialoge anzeigen
10.3.3 Standarddialoge mit AlertDialog
10.3.4 Dialoge für Datums- und Zeitauswahl
10.3.5 Der Fortschrittsdialog
10.3.6 Eigene Dialoge definieren
10.4 Benachrichtigungen mit Toasts
10.4.1 Toasts im Hintergrund-Thread
10.5 Fragen und Antworten
10.6 Übungen
11 Mehrseitige Apps
11.1 Intents
11.1.1 Was sind Intents?
11.1.2 Explizite und implizite Intents
11.1.3 Intent-Filter
11.2 Activities starten mit Intents
11.2.1 Intent-Objekte erzeugen
11.3 Intents empfangen
11.4 Ein Demo-Beispiel
11.5 Ergebnisse zurücksenden
11.6 Fragen und Antworten
11.7 Übung
12 Daten speichern
12.1 Preferences
12.2 Dateizugriffe
12.2.1 Zugriff auf internen Speicher
12.2.2 Externer Speicher (SD-Karte)
12.3 Die Reaktions-App
12.4 Fragen und Antworten
12.5 Übungen
13 Quiz-Apps
13.1 Aufbau und Benutzeroberfläche
13.2 Die Activity (QuizActivity.java)
13.3 Die Fragen (Frage.java)
13.4 Die Spielsteuerung (SpielLogik.java)
13.5 Verbesserungen
13.6 Frage und Antwort
13.7 Übung
14 Multimedia
14.1 Audioressourcen
14.2 Soundeffekte mit SoundPool
14.3 Das Universalgenie: MediaPlayer
14.3.1 Audioressourcen abspielen
14.3.2 Audiodateien vom Dateisystem abspielen
14.3.3 Audiodateien aus dem Internet abspielen
14.3.4 Auf das Abspielende reagieren
14.3.5 MediaPlayer-Objekte wiederverwenden
14.3.6 Ressourcen freigeben
14.3.7 Audiodateien wiederholt abspielen
14.4 Piepen und andere Töne
14.5 Bilddateien anzeigen
14.6 Videos abspielen
14.7 Fotos und Videos aufnehmen
14.8 Fragen und Antworten
14.9 Übungen
15 Sensoren
15.1 Zugriff
15.1.1 Was Sie benötigen
15.1.2 Welche Sensoren sind verfügbar?
15.1.3 Anmeldung beim Sensor
15.2 Sensordaten auslesen
15.2.1 Beschleunigungswerte ermitteln
15.2.2 Lagedaten ermitteln
15.3 Fragen und Antworten
15.4 Übung
16 Einsatz der Datenbank SQLite
16.1 Was ist eine relationale Datenbank?
16.2 Datenbank anlegen/öffnen
16.2.1 onCreate()
16.2.2 onUpgrade()
16.2.3 close()
16.2.4 Datenbanken als Ressourcen mitgeben
16.3 Datenzugriffe
16.4 Datenbankinhalte mit ListView anzeigen
16.5 Fragen und Antworten
16.6 Übung
17 Geolokation
17.1 Zugriff
17.1.1 Verfügbarkeit feststellen
17.1.2 Daten empfangen
17.1.3 Empfänger abmelden
17.2 Geokoordinaten
17.2.1 Sexagesimale und dezimale Darstellung
17.2.2 Das Location-Objekt
17.3 Eine GPS-Tracker-App
17.4 Fragen und Antworten
17.5 Übung
18 Brettspiel-Apps (TicTacToe)
18.1 Aufbau und Benutzeroberfläche
18.2 Die Start-Activity (MainActivity)
18.3 Spielfeld und Logik (TicTacToeView)
18.3.1 Vorbereitungen
18.3.2 Spielfeld zeichnen
18.3.3 Spielerzug durchführen
18.3.4 Computerzug mit AsyncTask durchführen
18.4 Verbesserungen
18.5 Frage und Antwort
18.6 Übung
19 Tipps und Tricks
19.1 Das Smartphone vibrieren lassen
19.2 UI-Code periodisch ausführen lassen
19.3 Bildergalerien mit GridView und BaseAdapter
19.3.1 Die Bildressourcen
19.3.2 Die Adapter-Klasse
19.3.3 Die GridView
19.3.4 Angeklickte Bilder als Vollbild anzeigen
19.4 Spinner verwenden (Listenfelder)
19.4.1 Den Spinner mit Daten füllen
19.4.2 Ereignisbehandlung
19.5 Mehrsprachige Apps
19.6 Schlussbemerkung
Teil IV Anhänge
A Anhang A: Apps veröffentlichen oder weitergeben
A.1 Die App vorbereiten
A.2 Digitales Signieren
A.3 Die App exportieren und signieren
A.4 Bei Google Play registrieren
A.4.1 Steuerliche Aspekte bei App-Verkauf
A.5 App hochladen
A.6 Weitergabe an Bekannte
B Anhang B: Android Studio
B.1 Android-Projekt anlegen
B.2 Projekt bauen (Build)
B.3 Projekte löschen
B.4 Eclipse-ADT-Projekt importieren
B.5 Run-Konfigurationen anpassen
B.6 Fenster zurücksetzen
B.7 Apps exportieren
B.8 Kleines Android Studio-Wörterbuch
C Anhang C: Emulator, ADM & Debugger
C.1 Der Emulator
C.1.1 AVD-Dateien
C.1.2 Emulator starten
C.1.3 Die Emulator-Bedienung
C.1.4 Apps installieren und deinstallieren
C.2 Android Device Monitor (ADM)
C.3 Der Debugger
C.3.1 Debug-Lauf starten
C.3.2 Debug-Möglichkeiten
C.4 Debugging-Beispiel
D Anhang D: Das Material zum Buch
E Anhang E: Lösungen
F Anhang F: Glossar
Dirk Louis
Peter Müller
Android
Der schnelle und einfache Einstieg
in die Programmierung
und Entwicklungsumgebung
2. Auflage
Alle in diesem Buch enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autoren und Verlag übernehmen infolgedessen keine juristische Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen – oder Teilen davon – entsteht.
Ebenso übernehmen Autoren und Verlag keine Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Buch berechtigt deshalb auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen und MarkenschutzGesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.
Bibliografische Information der Deutschen Nationalbibliothek: Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
Dieses Werk ist urheberrechtlich geschützt. Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren) – auch nicht für Zwecke der Unterrichtsgestaltung – reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden.
© 2016 Carl Hanser Verlag München
www.hanser-fachbuch.de
Lektorat: Brigitte Bauer-Schiewek
Copyediting: Sandra Gottmann, Münster-Nienberge
Herstellung: Irene Weilhart
Umschlagdesign: Marc Müller-Bremer, www.rebranding.de, München
Umschlagrealisation: Stephan Rönigk
Print-ISBN 978-3-446-44598-7
E-Pub-ISBN 978-3-446-44748-6
Verwendete Schriften: SourceSansPro und SourceCodePro (Lizenz)
CSS-Version: 1.0
Font License | Zurück zum Impressum |
Copyright 2010, 2012, 2014 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries. This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL ----------------------------------------------------------- SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ----------------------------------------------------------- PREAMBLE The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. DEFINITIONS "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. "Reserved Font Name" refers to any names specified as such after the copyright statement(s). "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. PERMISSION & CONDITIONS Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. TERMINATION This license becomes null and void if any of the above conditions are not met. DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
Vorwort |
Willkommen in der Android-Welt! Seitdem sich der Touchscreen als Standardoberfläche von Mobilfunktelefonen etabliert hat und vor Kurzem noch völlig unbekannte Features wie GPS-Empfänger und Lagesensor zur Standardausstattung gehören, gibt es kein Halten mehr: Jede Woche erscheinen neue Android-basierte Geräte und die Zahl der verfügbaren Apps im Android Market explodiert geradezu.
Wenn auch Sie dazugehören wollen, wenn Sie nicht bloß Anwender sein möchten, sondern daran interessiert sind, eigene Ideen in Apps umzusetzen ‒ sei es zum Spaß oder auch vielleicht als Einstieg in eine Existenz als selbstständiger Software-Entwickler ‒, dann kann Ihnen dieses Buch einen guten Einstieg (und ein bisschen mehr) in die Welt der App-Programmierung für Android-Systeme bieten.
Vorkenntnisse und Anforderungen
Wir wollen nichts beschönigen. Die Anforderungen an Android-Programmierer sind hoch. Doch mithilfe dieses Buchs und ein wenig Ausdauer und Mitdenken sollten Sie die größten Hürden meistern können.
Sehen wir uns dazu einmal an, welche Fähigkeiten ein Android-Programmierer besitzen muss und inwieweit Ihnen dieses Buch helfen kann, diese Fähigkeiten zu entwickeln.
Gute Kenntnisse der Programmiersprache Java
Sie erfüllen diesen Punkt nicht? Kein Grund zur Panik, aber lesen Sie unbedingt den nachfolgenden Abschnitt zum „idealen Leser“.
Umgang mit der integrierten Entwicklungsumgebung (IDE) Android Studio.
Alles, was Sie zum Umgang mit Android Studio im Allgemeinen wie auch im Hinblick auf die Erstellung von Android-Apps wissen müssen, lernen Sie in diesem Buch. Zusätzlich finden Sie am Ende des Buchs einen eigenen Anhang zu Android Studio, wo die wichtigsten Aufgaben noch einmal zusammengefasst sind (inklusive eines kleinen Wörterbuchs, das Lesern, die im Englischen nicht so versiert sind, die Eingewöhnung in die durchweg englische Benutzeroberfläche erleichtern soll).
Einsatz verschiedener Hilfsprogramme wie HierarchyViewer, Debugger und Emulator.
Insbesondere der Emulator ist für die Entwicklung von Apps unerlässlich, da Sie mit seiner Hilfe unterschiedlich ausgestattete Android-Geräte simulieren („emulieren“) können, ohne sie tatsächlich als echtes Gerät zu besitzen.
Unnötig zu erwähnen, dass wir Ihnen die wichtigsten Hilfsprogramme in diesem Buch vorstellen und Sie in die Arbeit mit ihnen einführen.
Wissen um den Aufbau von Apps und Kenntnis der Android-Klassenbibliothek
Dies ist das eigentliche Thema dieses Buchs. Wie sieht das Grundgerüst einer Android-App aus, worauf muss ich achten und was für tolle Sachen kann man mit der Android-Klassenbibliothek machen? (Kurzantwort: Nichts ist unmöglich!)
Nach dem erfolgreichen Durcharbeiten dieses Buchs werden Sie sicher noch kein Profi-Android-Entwickler sein. Das können und wollen wir Ihnen gar nicht versprechen, denn der Umfang an Material wäre so groß, dass kein Platz mehr für ausführliche Erläuterungen bliebe.
Sie werden aber eine sehr fundierte Grundlage erhalten, in viele fortgeschrittene Bereiche blicken und alles Notwendige lernen, um tolle Apps erstellen und sich selbstständig weiterbilden zu können.
Der ideale Leser, Java-Kenntnisse und das Java-Tutorium
Da es den idealen Leser im Grunde gar nicht gibt, sollten wir uns lieber fragen, welche Lesergruppen in welchem Umfang von dem vorliegenden Buch profitieren können:
Leser mit guten Java-Kenntnissen, die sicher objektorientiert programmieren können und bereits Erfahrung mit Konzepten wie Überschreibung, Interface-Implementierung, Ereignis-Listener und Threads haben, bilden eine der drei Hauptzielgruppen, für die dieses Buch geschrieben wurde. Sollten Sie zu dieser Gruppe zählen, legen Sie einfach los.
Leser mit grundlegenden Java-Kenntnissen bilden die zweite Hauptzielgruppe und sollten mit diesem Buch ebenfalls gut und schnell vorankommen. Sollten Sie zu dieser Gruppe gehören, achten Sie auf die im Buchtext eingestreuten Hinweise zu den Exkursen des Java-Tutoriums unter http://files.hanser.de/fachbuch/PDFs.zip. Mithilfe dieser Exkurse können Sie etwaige Wissenslücken zur Java-Programmierung schließen.
Umsteiger von anderen Programmiersprachen bilden die dritte Hauptzielgruppe. Doch Obacht! Es liegt viel Arbeit vor Ihnen, denn Sie müssen sich parallel auch noch mithilfe des Java-Tutoriums in Java einarbeiten. Sofern Sie allerdings bereits über gute Programmierkenntnisse in einer anderen objektorientierten Sprache (wie z. B. C++ oder C#) verfügen, dürfte dies für Sie keine große Schwierigkeit sein. Sie können das Tutorium vorab oder parallel zu diesem Buch lesen (die ersten Kapitel enthalten zu diesem Zweck Hinweise, wann Sie welche Teile des Tutoriums lesen sollten).
Bleibt die Gruppe der Leser, die über keine oder nur wenig Programmiererfahrung verfügen. Angehörigen dieser Gruppe können wir eigentlich nur empfehlen, sich zuerst einmal in die Java-Programmierung einzuarbeiten (beispielsweise mit unserem Java-Titel). Sie können es aber natürlich auch mit dem Java-Tutorium versuchen. Es geht zwar relativ flott voran, ist aber recht gut verständlich und beinhaltet sogar eine allgemeine Einführung in die grundlegenden Programmierkonzepte.
Aufbau des Buchs
Das Buch ist in drei Teile plus Anhang gegliedert.
Der erste Teil behandelt die Installation der notwendigen Entwicklerwerkzeuge und die Grundlagen der App-Erstellung.
Der zweite Teil vertieft die im ersten Teil angesprochenen Grundthemen: Code, Benutzeroberfläche, Arbeiten mit Ressourcen und der App-Lebenszyklus.
Der dritte Teil behandelt zahlreiche fortgeschrittene Aspekte wie z. B. Grafik, Menüs, Sensoren, Spiele, Datenbanken oder Geolokation. Er unterscheidet sich nicht nur inhaltlich, sondern auch konzeptionell von den beiden vorangehenden Teilen und ist eher im Stile eines Fortgeschrittenenbuchs geschrieben.
Abgerundet wird das Buch mit Anhängen zur Veröffentlichung von Apps, zur Entwicklungsumgebung Android Studio sowie zu weiteren Werkzeugen wie Emulator, ADM und Debugger, einem Glossar und einem ausführlichen Index.
Software, Beispiel-Apps und sonstiges Material zum Buch
Die Android-Enwicklungsumgebung, die Beispielsammlung und die Tutorials stehen für Sie zum Download bereit. Die Download-Links finden Sie in Anhang D: Das Material zum Buch. Bitte beachten Sie, dass es für die Android-Entwicklungsumgebung und den Java-SDK mehrere Download-Links gibt. Wählen Sie einfach den Link, der zu Ihrem Betriebssystem passt.
Die Website zum Buch
Wir haben dieses Buch mit großer Sorgfalt erstellt. Falls Sie auf Probleme oder Fehler stoßen, sollten Sie nicht zögern, uns eine E-Mail unter Angabe von Buchtitel und Auflage zu senden. Schauen Sie auch einmal auf unserer Buch-Website
www.carpelibrum.de
nach. Neben zusätzlichem Material, den Lösungsprojekten zu den Übungen, Aktualisierungen und Errata finden Sie dort auch weitere Bücher zum Thema Programmieren in Java, C++, C# u. a.
Viel Spaß in der Android-Welt wünschen Ihnen
Dirk Louis (autoren@carpelibrum.de)
Peter Müller (leserfragen@gmx.de)
Teil I: Einführung |
In diesem Teil geht es darum, dass Sie sich mit dem Aufbau von Android-Programmen und den Entwicklerwerkzeugen vertraut machen, die wir für die Erstellung von Android-Programmen (fortan kurz „Apps“ genannt) benötigen. Doch zunächst müssen wir diese natürlich erst einmal installieren.
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 beim Material zum Buch (siehe Anhang D) oder verteilt 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:
Android Studio
Android Studio ist eine integrierte Entwicklungsumgebung (kurz IDE), die viele spezialisierte Werkzeuge und Hilfsprogramme zur App-Entwicklung in einer gemeinsamen Oberfläche zusammenfasst. Dazu gehören beispielsweise ein Editor zum Aufsetzen der Programmquelltexte, ein Compiler zum Übersetzen der Quelltexte in Programmcode und ein Debugger zur schrittweisen Ausführung einer App zwecks Fehleranalyse, um nur die wichtigsten Helfer zu nennen. Android Studio erleichtert Ihnen als Entwickler die Arbeit und erlaubt zudem 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).
Android SDK
Das Android SDK1 enthält alle wichtigen Tools, Klassenbibliotheken und Dokumentationen, die für die Erstellung von Android-Apps benötigt werden.
Das Android SDK wird normalerweise zusammen mit dem Android Studio installiert. Wir werden es allerdings im Nachhinein noch etwas anpassen.
Java Development Kit (JDK)
Zum Ausführen von Android Studio und zum Kompilieren von Android-Apps wird ein aktuelles Java SDK (kurz JDK) benötigt. Es umfasst neben diversen Werkzeugen auch die Java-Laufzeitumgebung, die sogenannte JRE (Java Runtime Environment).
Die JRE wird nur für Android Studio und seine Hilfsprogramme benötigt. Die erzeugten Android-Apps brauchen natürlich auch eine Laufzeitumgebung, allerdings ist dies nicht die klassische JRE, sondern eine spezielle Variante, die vom Android-Gerät bereitgestellt wird (je nach Version heißt diese Laufzeitumgebung Dalvik oder ART).
ein Android-Smartphone zum Testen (optional)
einen nicht zu alten Rechner mit mindestens 5 Gbyte freiem Festplattenspeicher und mindestens 4 Gbyte Hauptspeicher und einem geeigneten Betriebssystem (unseres Wissens nach eignet sich jedes nicht zu alte Windows-, Mac OS- oder Linux-System). Realistisch betrachtet muss man hier anfügen, dass dies eine Minimalkonfiguration ist, die funktioniert, aber stellenweise viel Geduld erfordert. Für flottes Entwickeln brauchen Sie einen Rechner mit 8 bis 12 Gbyte und einer SSD.
Spaß am Programmieren, Ausdauer und auch ein bisschen Mut
1.2 | Installation des JDK |
Wie bereits erwähnt, benötigen wir zur App-Entwicklung unbedingt ein JDK in einer aktuellen Version (falls Sie bereits ein JDK installiert haben, können Sie es möglicherweise verwenden; sicherer ist aber eine Neuinstallation).
In Anhang D finden Sie den Download-Link der zu Ihrem System passenden JDK-Setup-Datei.
Windows- und Linux-Anwender müssen zudem die zu ihrem System passende 32-Bit- oder 64-Bit-Setup-Datei wählen.
Nach dem Download doppelklicken Sie auf die Setup-Datei, um das Setup-Programm zu starten, und folgen Sie den Anweisungen des Setup-Programms.
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.
Auf der Oracle-Website
http://www.oracle.com/technetwork/java/javase/downloads/index.html
können Sie das jeweils neueste Java SDK herunterladen.
1.3 | Installation von Android Studio |
In Anhang D finden Sie den Link zu der zu Ihrem System passenden Installationsdatei. Nach dem Download starten Sie das Programm und folgen Sie den weiteren Anweisungen (meistens einfach auf Next klicken). Achten Sie allerdings darauf, als Installationsort für Studio und SDK nicht die Vorgaben zu übernehmen, sondern einen neuen Ordner anzulegen (beispielsweise c:\Android). Die Erfahrung hat gezeigt, dass Sie damit vielen kleinen Problemen aus dem Weg gehen. Für den Rest des Buches gehen wir davon aus, dass Sie Android Studio und Android SDK nach c:\Android installiert haben.
Auf der Website
http://developer.android.com/sdk/index.html
können Sie die jeweils neueste Version des Android Studio herunterladen. Tun Sie dies aber möglichst erst nach Durcharbeiten dieses Buches! Android Studio wird fortlaufend überarbeitet, sodass sich beim Herunterladen der aktuellen Version Abweichungen zu den Abbildungen und Beschreibungen im Buch ergeben können.
Bild 1.1 Installationsort festlegen
Nach erfolgter Installation bietet Ihnen das Setup-Programm die Option an, Android Studio für Sie zu starten. Halten Sie hier bitte einen kurzen Moment inne.
Bild 1.2 Die Installation ist fast beendet
Falls Sie ein 64-Bit System haben (und daher die 64-Bit-Version von Android Studio verwenden) und in der glücklichen Lage sind, über mindestens 8 Gbyte Hauptspeicher zu verfügen, dann sollten Sie an dieser Stelle eine Einstellung von Android Studio ändern. Öffnen Sie hierzu die Datei C:\Android\Android Studio\bin\studio64.exe.vmoptions mit einem Texteditor. Editieren Sie die Zeile mit dem Eintrag -Xmx und setzen Sie den für Android Studio verfügbaren Speicher hoch (speichern nicht vergessen!), z. B.:
Stellen Sie als Nächstes sicher, dass Sie eine aktive Internetverbindung haben.
Kehren Sie nun zum obigen Abschluss-Dialog des Setup-Programms zurück. Lassen Sie das Häkchen für den Start von Android Studio aktiviert und beenden Sie mit Finish die Installation. Android Studio wird danach automatisch zum ersten Mal gestartet.
Android Studio basiert auf der IDE Intellij IDEA von JetBrains und ist unter professionellen Java-Programmierern sehr beliebt.
Falls Sie noch nie mit einer IDE gearbeitet haben, wird Sie die Fülle an Möglichkeiten einer IDE am Anfang „erschlagen“. Aber keine Sorge. Wir werden daher gerade in den ersten Kapiteln dieses Buches nebenbei auch des Öfteren auf den Umgang mit Android Studio selbst eingehen. Der Aufwand lohnt sich allemal, denn die Alternative ‒ Android-Programmierung mit bloßem Texteditor und dem reinen Android SDK ‒ birgt noch weitaus mehr Tücken.
Die wichtigsten Arbeitsschritte mit Android Studio haben wir überdies für Sie noch einmal im Anhang zusammengefasst.
1.3.1 | Erster Start |
Android Studio wird automatisch nach Abschluss der Installation gestartet. Unter Windows ist es auch über das Startmenü mit Programme/Android Studio bzw. Alle Apps/Android Studio aufrufbar.
ACHTUNG
Falls eine Fehlermeldung erscheint, dass keine JRE- oder JDK-Installation gefunden werden konnte, dann setzen Sie die Umgebungsvariable JAVA_HOME auf das Verzeichnis, wo Ihre Java-Installation liegt (unter Windows setzen Sie Umgebungsvariablen über das Startmenü: System/Systemeigenschaften/Erweitert/Umgebungsvariablen).
Beim ersten Start von Android Studio erscheint möglicherweise eine Meldung Ihrer Firewall, weil ein Zugriff auf das Internet versucht wird. Erlauben Sie dies, da weitere Komponenten heruntergeladen bzw. auf den letzten Stand gebracht werden.
Falls Sie eine Firewall-Software verwenden, die nicht von selbst beim Benutzer nachfragt, müssen Sie Android Studio manuell bei der Firewall eintragen und Internet-Zugriff erlauben.
Üblicherweise fragt Android Studio auch noch diverse Einstellungen für die erste Einrichtung ab. Klicken Sie sich dann einfach durch die Dialoge und übernehmen Sie die Voreinstellungen. Wenn Android Studio mit dem Download beginnt, machen Sie sich in Ruhe einen Kaffee oder Tee und warten Sie, bis Android Studio fertig ist.
Eventuell wird eine Fehlermeldung angezeigt, dass eine SDK-Komponente nicht installiert wurde. Klicken Sie in diesem Fall einfach auf Retry, dann verschwindet das Problem in der Regel.
Klicken Sie zum Schluss auf Finish. Der Startbildschirm von Android Studio erscheint.
Bild 1.3 Android Studio wurde das erste Mal gestartet
Englischkenntnisse sind für die Arbeit mit dem englischsprachigen Android Studio hilfreich. Eine Umstellung der IDE auf Deutsch ist nicht möglich. Für Leser, die mit der englischen Fachterminologie noch nicht so vertraut sind, haben wir daher im Anhang ein kleines Wörterbuch mit wichtigen Begriffen zusammengestellt.
Da Android Studio ständig aktualisiert wird, werden Sie von Anfang an Meldungen erhalten, dass es Updates für diverse Android Studio-Komponenten gibt. Solange Sie sich noch mithilfe dieses Buches in Android Studio einarbeiten, sollten Sie Android Studio möglichst nicht aktualisieren, da es sonst unnötige Abweichungen zwischen den Beschreibungen im Buch und der Software geben kann.
1.4 | Der Android-SDK-Manager |
Eigentlich könnten wir an diesem Punkt die Installation bereits als abgeschlossen ansehen und mit der Android-Programmierung beginnen. Doch es gibt da noch einen kleinen Aspekt, dem wir unsere Aufmerksamkeit schenken sollten.
1.4.1 | Die Android-Versionen |
Android gibt es in verschiedenen Versionen, manchmal auch Plattformen genannt. Und zu jeder Version gibt es eine zugehörige API2, die benötigt wird, um Android-Apps für die betreffende Android-Version zu schreiben, beispielweise gehört zu Android 6.0 (Codename Marshmallow) die API-Version 23. Wir verwenden im Buch Android 6.0, weil dies zu dem Zeitpunkt unserer Überarbeitung die aktuelle Version war. Wenn Sie das Buch in Händen halten, ist vermutlich schon 7.0 mit der API 24 oder 25 aktuell. Dies soll für Sie aber keine Rolle spielen. Verwenden Sie einfach zum Einstieg in die Android-Programmierung wie beschrieben Version 6.0 und API 23. Wenn Sie den Einstieg geschafft haben und dann in Ihren Apps auch Neuerungen von Android 7.0 nutzen möchten, können Sie jederzeit upgraden.
Android Studio (siehe Anhang D) installiert die jeweils aktuelle API (im Buch API 23). Mit dieser API können Sie nicht nur alle Neuerungen nutzen, sondern auch Apps schreiben, die zu älteren APIs, und damit auch älteren Android-Versionen, abwärtskompatibel sind.
Letzter Punkt ist extrem wichtig, denn nur die wenigsten Android-Anwender (sprich Kunden für Ihre Apps) aktualisieren bei jeder neu erscheinenden Android-Version ihr Smartphone.
Bild 1.4 Aktuelle Verteilung der Android-Versionen im Januar 2016 (Screenshot der Webseite
http://developer.android.com/resources/dashboard/platform-versions.html)
Wie Sie sehen können, konnten im Januar 2016 nur 0,5 % der Android-Anwender Apps auf ihren Smartphones ausführen, die auf Android 6.0 (API 23) basieren, während Apps, die mit der API 8 (Android 2.2 Froyo) auskommen, auf fast 100 % aller Android-Smartphones ausführbar sind (nämlich alle, die 2.2 und höher installiert haben).
Wenn Sie nun eigene Apps schreiben, können Sie beispielsweise festlegen, dass Sie zur Erstellung der App zwar die API 23 nutzen, die App aber abwärtskompatibel bis API 8 sein soll. Allerdings lauert hierbei eine kleine Falle.
Sie können zwar angeben, dass Ihre App zu einer älteren API abwärtskompatibel sein soll, aber die Android-Entwicklungsumgebung bewahrt Sie leider nicht davor, in einer solchen App Elemente zu verwenden, die dieser Abwärtskompatibilität widersprechen.
Sie sollten daher die Abwärtskompatibilität stets noch einmal explizit testen, bevor Sie eine App in die weite Android-Welt entlassen. Keine Angst, dies bedeutet nicht, dass Sie einen Satz von Smartphones mit den verschiedenen Android-Versionen anschaffen müssen. Zur Android-Entwicklungsumgebung gehört ein Emulator, mit dem Sie die verschiedensten Smartphones simulieren können. Um jedoch ein Smartphone für eine bestimmte Android-Version simulieren zu können, muss die zugehörige API (inklusive eines eigenen SDK) auf Ihrem Rechner installiert sein.
Und genau aus diesem Grund empfehlen wir Ihnen, schnell noch die API 16 zu installieren, um ggf. die Abwärtskompatibilität zu Smartphones ab Android 4.1 testen zu können. Damit haben Sie den größten Teil der aktiv genutzten Android-Versionen abgedeckt.
VERSIONEN UND APIS
Wie von jeder Software kommen auch von dem Android-Betriebssystem ständig neue und erweiterte Versionen (Plattformen) heraus. Zu jeder dieser Plattformen gibt es eine eigene API.
1.4.2 | APIs/SDKs und anderes nachinstallieren |
Zum Installieren weiterer SDK-Komponenten müssen Sie den sogenannten SDK-Manager öffnen. Klicken Sie hierzu auf der Startseite von Android Studio im Quick-Start-Bereich auf die Schaltfläche Configure (siehe Bild 1.3), dann auf die Schaltfläche SDK Manager.
Nun können Sie im Fenster des SDK-Managers unter dem Reiter SDK Platforms eine Übersicht sehen, welche API-Versionen bereits installiert sind bzw. welche installiert werden können. Wählen Sie nun aus, welche API nachinstalliert werden soll: API 16 (für Android 4.1).
Bild 1.5 Auswahl der zu installierenden Android SDKs
Wechseln Sie jetzt zum Reiter SDK Tools. Wählen Sie dort die Einträge Google USB Driver und ‒ falls noch nicht installiert ‒ Intel x86 Emulator Accelerator.
Bild 1.6 Auswahl weiterer Tools
Lassen Sie die ausgewählten Komponenten installieren, indem Sie auf OK klicken.
Unter Umständen erscheint ein Dialog, in dem Sie die Lizenzvereinbarungen annehmen müssen.
Das Herunterladen und Installieren der Komponenten wird vermutlich etwas länger dauern. Haben Sie also ein wenig Geduld. Anhand des Fortschrittsbalkens im SDK Manager-Fenster können Sie das Fortschreiten der Installation verfolgen.
Beenden Sie die Installation durch Klick auf Finish.
1.4.3 | Dokumentation und API-Referenz |
Lassen Sie uns nun kurz durch das Installationsverzeichnis des Android SDK streifen, um zu sehen, ob alle wichtigen Komponenten heruntergeladen wurden.
Bild 1.7 Das Verzeichnis des Android SDK
Unterverzeichnis | Inhalt |
tools | Hier sind die verschiedenen Hilfsprogramme des SDK zusammengefasst; darunter z. B. auch der Emulator, der ein Android-Smartphone simuliert und mit dessen Hilfe Sie Ihre Apps direkt auf dem PC testen können. |
platforms | Für jede Plattform (Android-Version), die Sie mithilfe des SDK-Managers heruntergeladen haben, finden Sie hier ein eigenes Unterverzeichnis mit der Programmierbibliothek (android.jar), individuellen Oberflächen für den Emulator (skins) und diversen anderen plattformspezifischen Dateien. |
platform-tools | Enthält plattformspezifische Hilfsprogramme |
docs | Hilfe und Dokumentation |
Besondere Aufmerksamkeit verdient das Verzeichnis docs. Hier finden Sie die vollständige Dokumentation zu Android, inklusive Programmierhandbüchern und API-Referenz, quasi ein lokales Abbild der Android-Website. Ausgangspunkt ist die Datei index.html.
Die Android-Hilfe ist komplett auf Englisch.
Bild 1.8 Die Startseite der lokal installierten Android-Hilfe
Datei | Inhalt |
file:///C:/Android/sdk/docs/sdk/index.html | Hier können Sie das neueste SDK herunterladen, sich über die Systemvoraussetzungen informieren oder Hilfe zur Installation finden. |
file:///C:/Android/sdk/docs/training/index.html | Hier finden Sie viele hilfreiche Tutorien. |
file:///C:/Android/sdk/docs/guide/index.html | Hier finden Sie Hinweise, Artikel und Hintergrundinformationen zu praktisch allen Aspekten der Android-Programmierung. |
file:///C:/Android/sdk/docs/reference/packages.html | Dies ist die Referenz der Elemente aus der Android-Bibliothek. |
Bild 1.9 Referenzdokumentation zur Android-Klasse Activity
1.5 | Wo Sie weitere Hilfe finden |
Weitere Informationen finden Sie auf der Support-Site zu diesem Buch
www.carpelibrum.de
und auf den Websites von Oracle
www.oracle.com
und Android
developer.android.com.
Sollten die Hinweise im Buch und auf der Website nicht ausreichen, haben Sie keine Scheu, sich per E-Mail an uns zu wenden (autoren@carpelibrum.de oder leserfragen@gmx.de).
1.6 | Nächste Schritte |
Der Rechner ist vorbereitet, die nötigen Hilfsmittel sind zusammengetragen, die Programmierumgebung ist eingerichtet. Nun wollen wir sehen, wie wir mithilfe dieser Programmierumgebung Apps erstellen, mit welchen Aufgaben wir bei der App-Programmierung konfrontiert werden und wie Apps grundsätzlich aufgebaut sind.
Für Programmieranfänger und Umsteiger von anderen Programmiersprachen ist jetzt ein guter Zeitpunkt, um mit dem Java-Schnellkurs unter http://files.hanser.de/fachbuch/PDFs.zip zu beginnen. Programmieranfänger sollten die Kapitel 1 bis 3 des Java-Tutoriums lesen. Umsteiger von anderen objektorientierten Sprachen können Kapitel 3 überspringen (sofern sie mit Begriffen wie Klassen, Instanziierung, Konstruktor, Methoden und Vererbung vertraut sind).
Wenn Sie möchten, können Sie auch bereits Kapitel 4 des Java-Tutoriums durcharbeiten, in dessen Zuge das Grundgerüst einer Java-Anwendung analysiert und das Konzept der Java-Bibliotheken und -Pakete vorgestellt wird. Es steht Ihnen aber auch frei, erst mit Kapitel 2 dieses Buchs zu beginnen und das Tutorium-Kapitel 4 dann parallel zu Kapitel 2.3 zu lesen.
1.7 | Frage und Antworten |
Die Versionsangaben zu Android sind ziemlich verwirrend. Gibt es da irgendwelche Regeln, die Ihnen helfen, besser durchzublicken?
Wichtig ist, zwischen Android-Betriebssystem und Android-API zu unterscheiden. Betriebssystemversionen werden üblicherweise mit Nachkommastelle angegeben (wie z. B. Android 4.4), die API-Nummern sind ganzzahlig. Leider gibt es keine Regel, wie man aus der Betriebssystemversion die zugehörige API ableiten kann. Man muss sich die Zuordnung einfach merken oder irgendwo nachschlagen (beispielsweise durch Aufruf des SDK-Managers).
1.8 | Übungen |
Falls Sie es noch nicht getan haben, sollten Sie jetzt Ihre Android-Entwicklungsumgebung einrichten.
Falls dies für Sie auch gleichzeitig der Einstieg in die Java-Programmierung ist, sollten Sie jetzt ‒ sofern Sie es nicht schon getan haben ‒, wie im Abschnitt 1.6 vorgeschlagen, mit dem Durcharbeiten der ersten Kapitel des Java-Tutoriums beginnen.
Fussnoten
1 SDK steht für „Software Development Kit“, grob übersetzt also ein „Bausatz zur Entwicklung von Software“.
2 API ist das Akronym für „Application Programming Interface“ und die Schnittstelle zu den Bibliotheksklassen, die Sie für die App-Programmierung benutzen.
2 | Auf die Plätze, fertig … App! |