Apps programmieren – Schritt für Schritt - Elektor

Stefan Schwark
Android
Apps programmieren – Schritt für Schritt

Stefan Schwark
Android-Apps
Elektor-Verlag, Aachen

Für meine Eltern
© 2012: Elektor Verlag GmbH, Aachen.
2. Auflage 2012
Alle Rechte vorbehalten.
Die in diesem Buch veröffentlichten Beiträge, insbesondere alle Aufsätze und Artikel sowie alle
Entwürfe, Pläne, Zeichnungen und Illustrationen sind urheberrechtlich geschützt. Ihre auch auszugsweise
Vervielfältigung und Verbreitung ist grundsätzlich nur mit vorheriger schriftlicher Zustimmung
des Herausgebers gestattet.
Die Informationen im vorliegenden Buch werden ohne Rücksicht auf einen eventuellen Patentschutz
veröffentlicht. Die in diesem Buch erwähnten Soft- und Hardwarebezeichnungen können
auch dann eingetragene Warenzeichen sein, wenn darauf nicht besonders hingewiesen wird. Sie
gehören dem jeweiligen Warenzeicheninhaber und unterliegen gesetzlichen Bestimmungen.
Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen.
Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autor
können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine
Haftung übernehmen.
Für die Mitteilung eventueller Fehler sind Verlag und Autor dankbar.
Korrektorat: Ute Marion Poeppel, Bonn
Umschlaggestaltung: Etcetera, Aachen
Satz und Aufmachung: InterMedia – Lemke e. K., Ratingen
Druck: WILCO, Amersfoort (NL)
Printed in the Netherlands
ISBN 978-3-89576-252-9
Elektor-Verlag GmbH, Aachen
www.elektor.de
119014-1/D

Inhaltsverzeichnis
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Über den Autor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1. Einführung in das Android-System. . . . . . . . . . . . . . . . . . . . . . . 9
1.1 Entwicklung ................................ 9
1.2 Android und Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Open Source-Projekte ......................... 13
1.4 Portierungen auf Endgeräte . . . . . . . . . . . . . . . . . . . . . 15
2. Die Eclipse Entwicklungsumgebung . . . . . . . . . . . . . . . . . . . . . 16
2.1 Die benötigte Software . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2 Android Virtual Devices . . . . . . . . . . . . . . . . . . . . . . . . 18
3. Grundlagen der Android Programmabarbeitung . . . . . . . . . . . . . 20
3.1 Komponenten des Systems . . . . . . . . . . . . . . . . . . . . . 20
3.2 Die Android-Manifest-Datei . . . . . . . . . . . . . . . . . . . . . 22
3.3 Die Android-API-Level . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.4 Die Android-Activity . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4. Das Android-User Interface. . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1 Views und ViewGroups. . . . . . . . . . . . . . . . . . . . . . . . . 30
4.2 Layout-Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.3 Layouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5. Android und JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1 JAVA-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.2 Android-Pakete. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3 Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.4 Sichtbarkeit von Variablen und Methoden . . . . . . . . . . . 49
6. Einfache Android Applikationen . . . . . . . . . . . . . . . . . . . . . . . . 51
6.1 Ein erstes App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.2 Ein einfaches Rechenprogramm . . . . . . . . . . . . . . . . . 56
6.3 Auswahllisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
6.4 Eine Stoppuhr als Android-App . . . . . . . . . . . . . . . . . . 85
6.5 Timer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6.6 Benachrichtigungen anzeigen. . . . . . . . . . . . . . . . . . . . 99
5

Inhaltsverzeichnis
6.7 Dateien lesen und schreiben . . . . . . . . . . . . . . . . . . . . 101
6.8 SMS versenden und empfangen .................. 108
7. Die Abfrage und Darstellung von Umweltdaten. . . . . . . . . . . . . . 118
7.1 Geo-Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7.2 Zeichnen auf dem Display . . . . . . . . . . . . . . . . . . . . . . 128
7.3 Ein GPS-Tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
7.4 GPS-Tracks speichern . . . . . . . . . . . . . . . . . . . . . . . . . 145
7.5 Die Abfrage von Sensoren . . . . . . . . . . . . . . . . . . . . . . 155
7.6 Widgets für das Display . . . . . . . . . . . . . . . . . . . . . . . . 168
8. Medienwiedergabe auf dem Smartphone . . . . . . . . . . . . . . . . . . 177
8.1 Eingebettete Sounddateien wiedergeben . . . . . . . . . . . . 177
8.2 Frequenzen ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . 180
8.3 Sounddateien aufnehmen . . . . . . . . . . . . . . . . . . . . . . 192
9. Apps für Webanwendungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
9.1 Das Anzeigen von Webseiten . . . . . . . . . . . . . . . . . . . . 201
9.2 Die Wiedergabe von Internet Videos . . . . . . . . . . . . . . . 207
9.3 Web Apps in Javascript und HTML . . . . . . . . . . . . . . . . 209
9.4 Eine App für Wikis . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
9.5 Datenbankabfragen über HTTP. . . . . . . . . . . . . . . . . . . 216
9.6 Socket-Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . 226
10. Android und Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
10.1 Rechte und Benutzer . . . . . . . . . . . . . . . . . . . . . . . . 233
10.2 Linux Kommandozeilenbefehle. . . . . . . . . . . . . . . . . . 234
Nachwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Anhang. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Javascript-Quellcodebeispiel. . . . . . . . . . . . . . . . . . . . . . . . 242
Android-Manifest-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Quellenverzeichnis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Abbildungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Webadressen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Stichwortverzeichnis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
6

Vorwort
Smartphones sind heutzutage ein normaler Begleiter im Alltag geworden.
Nur wenige Jahre nach der Markteinführung sieht man überall Menschen,
die über die Displays ihrer Telefone streichen. Doch was hat so
ein Smartphone an sich, dass so viele Leute ein solches Gerät besitzen
möchten. Wahrscheinlich hätten sich diese leistungsstarken Telefone
ohne die Entstehung der sozialen Netzwerke und der vielen sogenannten
Web 2.0-Anwendungen niemals so stark verbreitet. Aber diese kleinen
tragbaren Computer mit Telefonfunktion sind zu viel mehr in der Lage,
als nur die neuesten Nachrichten zu twittern oder über Facebook mit
Freunden zu chatten. Die äußerst leistungsstarke Hardware, die in einem
Smartphone enthalten ist, kann bei richtiger Programmierung erstaunliche
Dinge vollbringen. Auch lassen sich sehr einfach Programme für
die verschiedensten Anwendungen schreiben, sei es ein Rechenprogramm
oder eine Applikation für den Internetzugriff. Das Android-System
ist erstaunlich vielseitig und mächtig, so dass wenige Zeilen für ein Programm
ausreichen.
Hat man erst einmal die Programmierumgebung installiert und die ersten
Programme geschrieben, so wird man feststellen das es im Alltag genug
Problemstellungen gibt, für die es doch sehr praktisch wäre, wenn es ein
Programm für das Mobiltelefon geben würde. Was spricht also dagegen,
sich mal eben eine passende App zu programmieren.
Für solche Fälle wurde das vorliegende Buch geschrieben. Die hier gezeigten
Beispiele führen in die verschiedenen Besonderheiten des Android-
Framework ein. Anhand einfach gehaltener Programme wird hier gezeigt,
wie die grundlegenden Android-Objekte funktionieren und wie sie programmiert
werden. Die Bandbreite der Anwendungen reicht dabei von ganz einfachen
Rechenprogrammen, über praktische Anwendungen wie Zeitmesser,
bis zu Programmen, welche die Sensoren des Telefons abfragen und die
gemessenen Werte darstellen. Auch die Erstellung von Web-Applikationen,
welche mit Skript-Sprachen wie Javascript erstellt werden können, wird behandelt
und an Beispielen dargestellt.
7

Über den Autor
Für die Hilfe und Unterstützung bei der Erstellung dieses Buches möchte
ich mich bei meiner Lebensgefährtin und meinem Sohn sehr herzlich
bedanken und wünsche dem Leser viel Freude beim Lesen und Programmieren.
Über den Autor
8
Würselen im Januar 2012
Stefan Schwark wurde 1967 in Aachen geboren und ist staatlich geprüfter
Elektrotechniker. Nach dem Abschluss seiner Ausbildung zum Informationselektroniker
studierte er einige Semester Elektrotechnik an der Fachhochschule
in Aachen. Anschließend arbeitete er mehrere Jahre als Hardwareentwickler
und Programmierer bevor er sich im Jahre 2005
selbständig machte. Zu dieser Zeit begann er sich mit der Programmierung
von Mobiltelefonen zu beschäftigen und veröffentlichte 2007 das Buch
»JAVA ME fürs Handy«. Momentan arbeitet er als Programmierer für die
Steuerung und Visualisierung von Brennstoffzellensystemen.

1. Einführung in das Android-System
1.1 Entwicklung
Ursprünglich war Android ein Betriebssystem für Mobiltelefone. Die Entwicklung
von Android beginnt im Jahr 2003. In diesem Jahr wurde die Firma
Android Inc. gegründet. Die Firma war ein Start Up-Unternehmen, das sich
mit der Entwicklung von Software für Mobiltelefone befasste. Über die eigentlichen
Entwicklungen ist wenig bekannt. Android Inc. Mitbegründer Jeff
Rubin, heute ›Director of mobile Platforms‹ bei Google, erklärte 2003 in
einem Interview mit der Zeitschrift ›Business Week‹, dass man sich mit der
Entwicklung von Mobiltelefonen befasst, die Informationen zum Standort
des Benutzers erfassen könnten. Veröffent lichungen gab es jedoch keine.
Die Webseite der Firma zeigte in dieser Zeit einige sehr kuriose Sachen, wie
Comics oder private Empfehlungen, gab jedoch keinerlei Informationen über
Entwicklungen oder Unternehmenszweck an. Trotzdem wurde Android Inc.
2005 von Google erworben. Dies geschah zu einem Zeitpunkt, als Google
mehrere kleine Start Up-Unternehmen aufkaufte. Da zu diesem Zeitpunkt
die Firma Apple das iPhone bereits entwickelte, welches Anfang 2007 auf
den Markt kam, gab es schon bald Gerüchte über das sogenannte gPhone.
Also ein von Google entwickeltes Mobiltelefon. Nahrung bekamen diese Gerüchte,
als Gespräche zwischen großen Mobiltelefon-Herstellern und Google
bekannt wurden. Google dementierte zwar, aber das Gerücht hielt sich nachhaltig.
Bis zum 5. November 2007, als Google erklärte, man würde kein
Mobiltelefon entwickeln, sondern ein Betriebssystem. Die Gespräche mit
den anderen Firmen hatten den Zweck die Open Handset Alliance zu gründen.
Diese ist ein Zusammenschluss mehrerer großer Unternehmen aus der
Mobilfunk Branche. Neben Herstellern von Telefonen wie LG, Samsung und
HTC, finden sich hier ebenso Hersteller der benötigten Chips und auch Provider
und Netzanbieter wie z. B. T-Mobile. Die Entwicklung von Android lag
von nun an in der Hand dieser Vereinigung. Android stammt also nicht nur
von Google, obwohl die Firma eine treibende Kraft ist, sondern ist ein freies
und quell-offenes Betriebssystem, welches unter der Apache-Lizenz von der
Open Handset Alliance veröffentlicht wird.
Nachdem man die Entwicklung der Öffentlichkeit angekündigt hatte, ging
es recht schnell vorwärts. Bereits eine Woche später wurde die erste Ver-
9

1. Einführung in das Android-System
sion des Software Development Kits (= SDK) veröffentlicht. Kurze Zeit danach
stellten die ersten Chiphersteller schon die ersten Chipsets vor, die
einen ersten Ausblick auf die Fähigkeiten des kommenden Systems ermöglichten.
Die grundlegende Idee bestand darin, das Betriebssystem zusammenbauen
zu können, indem man einzelne Komponenten einfach kombiniert.
Was sich zunächst einfach anhört, war damals jedoch nicht üblich.
Die Telefonhersteller hatten alle eigene Versionen von Betriebssystemen
und eine Erweiterung war zunächst aufwendig und musste immer für die
passende Hardware erstellt werden. Mit Android konnten dann auch Module
von anderen Herstellern integriert werden, was die Entwicklung vereinfachte.
Android ist nicht nur ein Betriebssystem. Android ist eine Sammlung von
mehreren Komponenten, die erforderlich sind, um eine bestimmte Funktionalität
zu erlangen. So etwas nennt man dann ›Software Stack‹. Ein solcher
Software Stack beinhaltet verschiedene Teile, die die verschiedenen
Aufgaben übernehmen, die benötigt werden, um eine Anwendung vollständig
zu realisieren. Das ist dann nicht nur das Betriebssystem, sondern auch
verschiedene Schichten darüber. Im Falle von Android besteht der Software
Stack aus dem Betriebssystem, der sogenannten Middleware und einigen
Programmen, welche die wichtigsten Funktionen bereitstellen.
Basis des Betriebssystems ist ein Linux 2.6 Kernel. Der Kernel kümmert sich
um die Kommunikation mit der eigentlichen Hardware. Er sorgt für die Verwaltung
des Arbeitsspeichers und der ablaufenden Prozesse. Der Kernel stellt
hier eine Hardware-Abstraktionsschicht dar. Das heißt, er besitzt logische
Schnittstellen, über die er mit der nächsthöheren Schicht kommuniziert. Das
hat den Vorteil, dass der Kernel der einzige Teil des Systems ist, der von der
verwendeten Hardware abhängig ist. Diese Architektur macht es möglich,
das Android-Betriebssystem für viele verschiedene Geräte zu portieren. So
gibt es mittlerweile Android für verschiedenste Mobiltelefone und Tablet-
Computer, als PC-Version für X86 Prozessoren und für zahlreiche andere
Plattformen bis hin zu eingebetteten Systemen.
Über der Kernelschicht steht dann die Middleware. Hierbei handelt es sich
um eine Sammlung von Software, die die Verbindung zwischen der Applikation
und dem Kernel regelt. Der wichtigste Teil ist die, von dem Google-
Mitarbeiter Dan Bornstein entwickelte Dalvik-Maschine. Diese virtuelle Maschine
stellt die JAVA-Laufzeitumgebung dar. Der Name Dalvik wurde von
10

Bornstein nach einer Stadt in Island gewählt, in der einige seiner Vorfahren
lebten. Die Dalvik-Maschine selbst, ist für die Ausführung des JAVA-Codes
zuständig. Im Unterschied zu der normalen JAVA-Maschine ist die Dalvik-
Maschine anders konzipiert. Der Unterschied liegt im zugrunde liegenden
theoretischen Konstrukt. Bei der normalen JAVA-Virtual-Maschine handelt
es sich um einen Kellerautomaten, während die Dalvik-Maschine als Registermaschine
ausgeführt ist. Da das Modell der Dalvik-Maschine besser an
moderne Prozessoren, wie den für Mobil telefone sehr häufig verwendeten
ARM-Mikroprozessor angepasst ist, arbeitet es hier wesentlich ressourcensparender.
Das ist ein wesentlicher Punkt, da Android für jeden Prozess eine
neue Maschine startet. Da die Ressourcen eines Mobiltelefons jedoch eher
begrenzt sind, muss die Dalvik-Maschine sich mit wesentlich weniger zufrieden
geben als eine Virtual-Machine auf einem PC. Die Dalvik-Maschine ist
auch wieder ein eigenes Open Source-Projekt und auch unter der Apache-
Lizenz veröffentlicht. Zur Dalvik-Maschine gibt es auch ein eigenes Software
Development Kit, welches auf der Projektwebseite erhältlich ist.
1.2 Android und Linux
1.2 Android und Linux
Da Android zu einem großen Teil auf Linux basiert, könnte man sagen: Android
ist Linux. Das wäre aber nur zu einem Teil richtig. Android besteht
zwar aus einem Linux-Kern, aber der Rest des Systems hat zunächst einmal
nichts mit dem Betriebssystem zu tun. Trotzdem ist es ratsam einen Blick
auf diesen Unterbau zu werfen, da hier einige Gründe für bestimmte Verhaltensweisen
des Android-Systems liegen.
Auch wer mit Linux bisher noch nie etwas zu tun hatte, kennt dieses Betriebssystem
aus den diversen Veröffentlichungen und Beilagen in den Computerzeitschriften.
Hierbei handelt es sich jedoch um Linux-Distributionen, welche
eine Zusammenstellung des eigentlichen Systems mit diversen Programmen
und Anwendungen darstellten. Der Kern des Systems ist wesentlich kleiner.
Grundsätzlich besteht Linux nur aus einem Kernel mit diversen Treibern bzw.
Modulen. Selbst die darauf aufsetzende Shell, die nur eine einfache Kommandozeile
zur Ver fügung stellt, hat mit dem eigentlichen Linux-System schon
nichts mehr zu tun, sondern stellt in der Regel ein eigenes Projekt dar. Es besteht
deswegen auch die Möglichkeit, diese Programme auszutauschen und
den eigentlichen Bedürfnissen anzupassen. Deswegen basieren viele Geräte
11

1. Einführung in das Android-System
Bild 1: Das Android-Framework
12

1.3 Open Source-Projekte
für den heimischen Gebrauch, wie Router oder Netzwerkfestplatten aus kleinen
Linux-Systemen mit einer minimalen Kommandoshell und den für den Betrieb
nötigen Programmen. Für viele dieser Systeme gibt es daher auch andere Firmware
Images, die auf Linux-Projekten wie z. B. OpenWRT basieren. Oft ist es
aber auch möglich, komplette Debian-Linux-Installationen auf solchen Geräten
unterzubringen. So entsteht dann aus der ausgedienten USB- Dockingstation
z. B. eine IP-Webcam. Es gibt im Internet mittlerweile eine ganze Reihe solcher
Projekte. Zu diesen gehören auch die zahlreichen Portierungen, welche es ermöglichen,
Android auch auf nicht dafür bestimmten Geräten zu installieren.
Da eine solche Portierung jedoch eine sehr genaue Kenntnis des zugrunde
liegenden Systems voraussetzt, würde das Thema den Rahmen dieses Buches
sprengen. Trotzdem ist es ratsam, sich etwas mit diesem Betriebssystem
und seinen Eigenheiten, wie der Benutzerverwaltung und der grundsätzlichen
Bedienung, vertraut zu machen. Es besteht nämlich durchaus
die Möglichkeit, von einer Android-Applikation aus, auf das Linux-System
zuzugreifen und dort auch Befehle auszuführen. Ebenso wie Linux kennt
Android einen Root User, welcher auf dem System uneingeschränkten Zugriff
hat. Aus diesem Grund existieren auch zahlreiche Anleitungen und
Apps im Android-Market, die es erlauben unter "diesem Benutzer" auf dem
Smartphone zu arbeiten. Nur unter "diesem Benutzer" ist es z. B. möglich,
bestimmte Einstellungen des Gerätes zu verändern. Wenn man also z. B.
die Taktfrequenz seines Smartphone erhöhen will, dann geht das nur, wenn
man die Rechte des Root Users hat.
1.3 Open Source-Projekte
Nicht jede Applikation muss neu geschrieben werden. Viele Anwendungen
sind so komplex, dass es keinen Sinn machen würde, sich alleine zu Hause
hinzusetzen und mit einem enormen Zeitaufwand das Rad neu zu erfinden.
Stattdessen spart einem der Blick ins Internet oft eine Menge Zeit. Zumindest
gibt es jedoch einen guten Überblick darüber, was bereits realisiert
wurde. Es ist außerdem immer gut, sich anzusehen, wie ein Problem von
anderen gelöst wurde.
Ein Beispiel für ein solches Open Source-Projekt stellt ›gmote‹ dar. Wie für
Android üblich unter der Apache-Lizenz veröffentlicht, ist ›gmote‹ eine
13

1. Einführung in das Android-System
Applikation, welche die Fernsteuerung des Rechners über das Android-
Smartphone ermöglicht.
Open Source-Projekte werden in der Regel auf einer Projektwebseite veröffentlicht.
Hier gibt es alle zum Projekt relevanten Informationen, soweit
die Projektbetreuer sie veröffentlicht haben. Zunächst einmal kann man
hier immer die Lizenz finden, unter der das Projekt veröffentlicht ist. Diese
sollte man sich durchlesen, falls man z. B. eine kommerzielle Nutzung vorhat
oder an dem Projekt mitarbeiten möchte. Eine Dokumentation des Projektes
ist in der Regel auch immer auf der Webseite zu finden. Oftmals
ergänzt durch ein Wiki oder ein Forum in dem Fragen gestellt werden
können. Manche Projekte bieten auch Unterstützung durch IRC-Channels,
in denen den Entwicklern direkt Fragen gestellt werden können.
Die Projekte werden dann meistens in der Form von Source Code veröffentlicht.
Entweder als Archiv zum Herunterladen oder auch innerhalb eines
Revision Control Systems, bei dem der Quellcode über einen Client für dieses
System ausgelesen werden kann. Das am meisten verwendete System
ist die Software ›Apache Subversion‹. Es gibt für dieses System Client-
Software für jedes Betriebssystem und es kann in mehrere Entwicklungsumgebungen
und Editoren integriert werden.
Hat man das passende Projekt gefunden, kann man sich den Quellcode
herunterladen und diesen selber in seiner eigenen Entwicklungsumgebung
bearbeiten. Oftmals kann die Software schon fast alles, was man zu programmieren
vorhatte. So fehlen nur ein paar Punkte, um die gewünschte
Applikation für das eigene Problem zu bekommen. Diese kann man jetzt
selber schreiben und den Quellcode erweitern. Bevor man nun aber dieses
Programm stolz auf seiner Webseite präsentiert oder gar versucht im
Android-Market zu verkaufen, gilt es daran zu denken, das dies keine Software
ist, die man selber geschrieben hat. Wenn die Lizenzbedingungen eine
kommerzielle Nutzung ausschließen, dann kann man es nicht verkaufen.
Ebenso gehört zu einer Veröffentlichung immer der Hinweis auf das zugrunde
liegende Projekt. Man kann natürlich auch einfach an dem Projekt
mitarbeiten und seine Erweiterungen so der Allgemeinheit zur Verfügung
stellen. Der Nächste wird davon profitieren.
14

1.4 Portierungen auf Endgeräte
1.4 Portierungen auf Endgeräte
Android ist auf viele Endgeräte portierbar. Die Quelloffenheit des Betriebssystems
ermöglicht es, das System sogar an Geräte anzupassen, für die
keine Originalversion des Herstellers zu finden ist. So gibt es mittlerweile
mehrere Portierungen für Android-fremde Mobiltelefone im Internet. Auch
für den Einsatz auf Tablet-PCs ist Android verfügbar. Portierungen sind
hier u. a. für ASUS eepC zu finden.
Obwohl Android ursprünglich für den Einsatz auf Mobiltelefonen gedacht
war, interessiert sich mittlerweile auch die Industrie für den Einsatz des
Betriebssystems. Zur Zeit existieren schon mehrere Firmen die Android
für Steuerungs- und Visualisierungsaufgaben einsetzen. Hier wird dann
der zugrunde liegende Linux-Kernel an das Zielsystem, meistens ein Embedded
System für den Einsatz in der Industrie, angepasst. Im Prinzip
lässt sich das ohne viel Hardwareaufwand auch zu Hause realisieren, da
es auch preisgünstige Embedded Linux-Systeme auf dem Markt gibt. Ein
Beispiel hierfür ist das weit verbreitete Beagleboard, welches im Hobbybereich
sehr beliebt ist und für das bereits Portierungen existieren.
Die Menge der im Internet veröffentlichten Anwendungen und Portierungen
steigt ständig, so dass es den Rahmen eines Buches sprengen würde, diese
auch nur annähernd darzustellen. Prinzipiell eignet sich jedes System, welches
über die Möglichkeit verfügt, ein Display anzuschließen und auf dem
eine Linux-Variante installiert werden kann. Es lassen sich zwar auch Anwendungen
realisieren, die das User Interface nicht benutzen, aber da stellt
sich die Frage nach dem Sinn des Einsatzes eines Android-Framework.
15

2. Die Eclipse-Entwicklungsumgebung
2.1 Die benötigte Software
Schauen wir uns nun einmal an, wie so eine App aufgebaut ist und wie sie
programmiert wird. Hierzu benutzen wir die freie Entwicklungsumgebung
Eclipse, welche für alle Plattformen verfügbar ist. Zusätzlich zu der Entwicklungsumgebung
benötigen wir noch ein aktuelles JAVA-Runtime Environment,
da Eclipse ohne dieses Environment nicht ausgeführt werden kann. Um die
einzelnen Schritte darzulegen, gehen wir von einem frisch installierten Betriebssystem
aus.
Als erstes installieren wir das JAVA-Development Kit (= JDK), vorzugsweise
in der aktuellen Version, welches von der Webseite der Firma Oracle heruntergeladen
werden kann. In diesem Development Kit ist das für die
Eclipse-IDE (= Integrated Development Environment) benötigte JAVA-Runtime
Environment bereits enthalten, so dass es nicht extra installiert werden
muss. Die Installation sollte problemlos verlaufen, da die einzigen Sachen
die hier beachtet werden müssen, die eventuell nicht gewünschte Toolbar
für den Internet Browser oder die manchmal unbeliebte automatische
Update-Funktion ist. Beide Optionen können im Verlauf des Installationsprozesses
abgewählt werden.
Nachdem das Runtime Environment installiert wurde, kann nun die eigentliche
Entwicklungsumgebung installiert werden. Diese kann von der Website
des Eclipse-Projektes heruntergeladen werden. In unserem Fall ist die
Classic-Version eine gute Wahl, da sie alles enthält, was für die Entwicklung
benötigt wird. Auch hier sollte die Installation ohne große Probleme
funktionieren. Nach der Fertigstellung kann die IDE gestartet werden. Wenn
alles richtig verlaufen ist, fragt die Software nach dem zu verwendenden
Workspace-Verzeichnis. Dieses kann als Defaultwert festgelegt und sollte
gespeichert werden, wenn man nicht bei jedem Start erneut gefragt werden
möchte.
Damit wir jetzt auch Programme für Android entwickeln können, benötigen
wir jedoch noch einiges mehr an Software. Deswegen laden wir im nächsten
Schritt das aktuelle Software Development Kit (= SDK) für Android
16

2.1 Die benötigte Software
herunter. Das SDK kann im Development-Bereich der Android-Webseite
unter www.android.com heruntergeladen werden. Bei der Installation wird
geprüft, ob bereits ein JDK installiert wurde. Wenn das noch nicht geschehen
ist, etwa weil nur ein JAVA-Runtime Environment installiert wurde,
muss dieser Schritt jetzt nachgeholt werden. Je nachdem, welche Version
des Android-SDK he runtergeladen wurde, ist die Installation etwas unterschiedlich.
Für Microsoft Windows ist es die beste Wahl, das Installationspaket
mit Installer herunterzuladen. Für Linux oder Mac-Systeme kann das
SDK als gepacktes Archiv heruntergeladen werden. Dieses Archiv wird dann
einfach an der gewünschten Stelle entpackt. Die weitere Installation erfolgt
über die Eclipse-Entwicklungsumgebung.
Bild 2: Die Eclipse-
Entwick lungsumgebung
Um das Android-SDK in die Eclipse-IDE einzubinden, ist ein extra Plugin
für Eclipse verfügbar. Dieses ADT-Plugin muss als nächstes installiert werden.
Dazu wird Eclipse gestartet. In der Menüleiste ist unter dem Punkt
›Help‹ der Unterpunkt ›Install new Software‹ zu finden. Dieser wird ausgewählt
und es erscheint der Dialog für die Installation neuer Software. Durch
Klick auf den ›Add‹-Button wird nun ein Eingabefeld aufgerufen, in dem
eine neue Quelle für die Installation eingegeben werden kann. Als Namen
kann der von Android vorgeschlagene ›ADT-Plugin‹ verwendet werden. In
17

2. Die Eclipse-Entwicklungsumgebung
das Feld Location muß nun die Adresse eingetragen werden, unter der das
Archiv für das Plugin heruntergeladen werden kann. Diese lautet:
https://dl-ssl.google.com/android/eclipse/
Aus Sicherheitsgründen sollte die https-Adresse verwendet werden. Sollten
sich damit Probleme ergeben, empfiehlt Android die Installation mit
http zu versuchen. Nach Klicken auf den ›OK-Button‹ wird nun das Archiv
geladen. Nach kurzer Zeit erscheint der Punkt ›Developer Tools‹ im Auswahlfenster.
Dieser wird nun angeklickt und nach Klicken auf ›Next‹ wird
zum Akzeptieren der Lizenzbestimmungen aufgefordert. Nachdem man
die Lizenzbedingungen gelesen oder zumindest zur Kenntnis genommen
hat, werden diese nun akzeptiert und durch Klicken auf ›Finish‹ die
Installation gestartet. Nachdem nun alle Dateien installiert sind, wird zum
Neustart von Eclipse aufgefordert und damit ist die Installation des Plugins
abgeschlossen.
2.2 Android Virtual Devices
Das neue Plugin ist nun im Menüpunkt ›Window‹ zu finden. Hier wurde der
Menüpunkt ›Android SDK und AVD Manager‹ hinzugefügt. Ein Klicken auf
diesen Menüpunkt führt jedoch zunächst einmal zu einer Fehlermeldung.
Das liegt daran, dass Eclipse noch nicht weiß, wo das Android SDK zu finden
ist. Das muss nun zunächst noch unter ›Window → Preferences‹ eingestellt
werden. Hier ist unter dem Punkt ›Android‹ der Pfad des SDK einzutragen.
Für Windows-Systeme also z. B. ›.../Programme/Android‹, bei
Linux-Systemen der Ort, an dem das SDK entpackt wurde. Dies kann z. B.
das Home-Verzeichnis sein. Nachdem man den Eintrag bestätigt hat, wird
überprüft, ob alle benötigte Software vorhanden ist. Für den Fall, dass etwas
fehlt, wird man nun vom SDK-Manager darauf hingewiesen und kann die
benötigten Teile hier installieren. Der Einfachheit halber installiert man am
besten einfach alle Pakete, die zur Verfügung stehen. Das ist in der Regel
eine relativ große Zahl und dauert dementsprechend lange.
Nachdem nun endlich alle benötigte Software installiert wurde, braucht
man für eine Applikation natürlich auch ein Endgerät, auf dem dieses Programm
laufen soll. Damit wir das erste Programm für Android auch laufen
18

2.2 Android Virtual Devices
lassen und testen können, brauchen wir noch ein sogenanntes AVD (Android
Virtual Device), also einen Emulator auf dem das Programm ausgeführt
werden kann. Zu diesem Zweck wechseln wir wieder in Eclipse und rufen
hier erneut den AVD-Manager im Window-Menü auf. Hier gibt es den Menüpunkt
›Virtual Devices‹ unter dem wir unsere AVD erstellen können. Nach
Klicken auf ›New‹ erscheint ein Dialogfeld, in dem wir die Einstellungen für
unser AVD vornehmen können. Für unsere erste App reicht es, einen Namen
zu vergeben und die Zielplattform auszuwählen. Die Zielplattform ist das
Gerät, auf dem die App später laufen soll, also z. B. ein Gerät mit Android 2.1.
Das wird nun hier ausgewählt und anschließend kann durch Klicken auf
›Create‹ die AVD erstellt werden.
Bild 3: Der Dialog für die Erstellung eines
neuen Android-Device
19

3. Grundlagen der Android-Programmabarbeitung
3.1 Komponenten des Systems
Wie bereits erwähnt, werden Android-Programme in JAVA programmiert.
Damit aus diesem Quellcode ein fertiges Programm für den Einsatz auf
einem Mobiltelefon oder einem anderen System wird, muss der Programmcode
vom Android-SDK zunächst übersetzt und anschließend mit
den im Projekt erstellten Ressourcen zusammengepackt werden. Hieraus
erstellt das SDK nun ein Android-Installationspaket. Dieses Paket ist im
Wesentlichen eine Archivdatei in der die einzelnen Komponenten enthalten
sind. Diese Datei trägt die Endung .apk. Eine solche .apk-Datei enthält
eine komplette Applikation und ist der normale Weg, diese auf einem
Android-System zu installieren. Dazu muss dieses Archiv nur auf das
Gerät kopiert werden, auf dem das Programm installiert werden soll. Ein
Anklicken oder Tippen startet dann den Installations prozess.
Damit die Applikation keine anderen Programme bei der Arbeit stören
kann, sind verschiedene Sicherheitsmechanismen im Android-Framework
und dem darunterliegenden Linux-System vorgesehen. So wird z. B. jede
Applikation unter einem anderen Benutzer ausgeführt, was mit dem Linux-
System ohne Probleme möglich ist. Zu diesem Zweck teilt das System dem
Anwenderprogramm eine einzigartige ID zu, welche nur für diese Applikation
gültig und auch nur diesem System bekannt ist. Das Anwenderprogramm
kann auf diese ID nicht zugreifen. Aufgrund dieser ID werden nun
die Zugriffsrechte für die Applikation und ihre Ressourcen gesetzt, so dass
nur dieses Programm darauf zugreifen kann.
Für jede Applikation wird nun eine eigene Dalvik-Maschine gestartet, die
in einem eigenen Linux-Prozess läuft. Dadurch kann kein Programm ein
anderes stören oder das System beeinträchtigen. Das Android-Framework
verwaltet hierbei den Lebenszyklus der Applikation, indem es einen neuen
Prozess startet, sobald dieser benötigt wird. Wenn das Programm beendet
wird, so sorgt Android auch wieder für die Freigabe der Systemressourcen.
20

3.1 Komponenten des Systems
Diese Vorgehensweise wird als principle of least privilege e bezeichnet. Das
bedeutet, dass als Voreinstellung der Applikation, so gut wie keine Rechte
für den Zugriff auf andere Komponenten gegeben werden.
Es gibt jedoch auch Ausnahmen von dieser Regel, damit ein Android-Programm
seine Daten mit einem anderen Programm teilen kann. Dazu gibt
es zwei Möglichkeiten. Man kann dafür sorgen, dass beide Applikationen
unter einer gemeinsamen Linux-ID ausgeführt werden. Dies erlaubt dann
natürlich beiden Applikationen untereinander Ressourcen freizugeben, da
das System nicht unterscheiden kann, welches Programm den Zugriff vornimmt.
Die zweite Möglichkeit besteht darin, vom Benutzer die Erlaubnis
für den Zugriff zu erfragen. Hierzu muss die Applikation für jeden Zugriff
auf Daten, wie z. B. das Telefonbuch oder Hardware-Geräte, wie die Kamera
oder Bluetooth, die benötigten Rechte gewährt bekommen. Diese
Rechte werden bei der Installation des Programmes vom Benutzer zugeteilt.
Android-Apps können prinzipiell aus vier verschiedenen Komponenten bestehen.
Das sind die vier Typen: Activity, Service, Content Provider und
Broadcast Receiver. Jede dieser verschiedenen Komponenten hat einen bestimmten
Anwendungsfall innerhalb des Android-Systems und einen unterschiedlichen
Lebenszyklus.
Das erste ist die Activity. Eine Activity stellt genau einen Bildschirm mit
einem Benutzerinterface dar. Eine komplette Applikation kann also aus einer
oder mehreren Activities bestehen. Jede Activity läuft zunächst einmal
für sich alleine. Durch das Zusammenwirken im Android-Framework entsteht
für den Benutzer jedoch der Eindruck eines zusammenhängenden
Programms. Eine Activity kann aber auch von einem anderen Programm
aufgerufen werden, sofern sie es erlaubt. So ist es z. B. möglich, ein Photo
an ein Mailprogramm zu übergeben und von diesem versenden zu lassen.
Man programmiert also nicht alles in das Kameraprogramm, sondern nutzt
einfach die Funktionen bereits vorhandener Software aus.
Eine weitere Komponente des Android-Framework stellen die Services dar.
Hierbei handelt es sich um Prozesse, welche kein Benutzerinterface benötigen
und im Hintergrund ablaufen, um entweder sehr lange laufende Programmteile
auszuführen oder mit anderen Prozessen zu kommunizieren. Ein
Service kann von einer anderen Komponente gestartet werden und kann
21

3. Grundlagen der Android-Programmabarbeitung
anschließend Daten mit dieser, oder einer anderen Komponente an ihn angebundenen,
Daten auszutauschen.
Bei einem Content Provider handelt es sich um eine Komponente, welche
den Zugriff auf Daten ermöglicht. Dabei ist es egal, ob es sich um Daten
in einer Datei, einer Datenbank oder dem Internet handelt. Die Applikationen
können mit Hilfe des Content Provider auf die Daten zugreifen und
brauchen sich dabei nicht um den Ort oder das Format der Daten zu kümmern.
So kann ein Programm z. B. über ein einheitliches Interface auf das
Adressbuch des Gerätes zugreifen und daraus Informationen beziehen.
Natürlich auch hier nur, wenn ihm die passenden Rechte gewährt wurden.
Die vierte Komponente eines Android-Systems ist der Broadcast Receiver.
Dieser Receiver arbeitet mit Meldungen des Systems und reagiert darauf,
wenn er über die entsprechende Funktion verfügt. Broadcast Receiver haben
in der Regel keine großen eigenen Programmfunktionen und sind nur
dafür zuständig, eine bestimmte Aktion anzustoßen, sobald ein Ereignis
geschieht, wie z. B. der Empfang einer SMS oder auch das Ver löschen der
Displaybeleuchtung.
Eine Besonderheit des Android-Systems besteht darin, dass eine Applikation
Komponenten einer anderen Applikation starten kann. Da dieses nicht
direkt möglich ist, muss hierzu eine Nachricht über das System geschickt
werden. Diese Systemnachricht heißt ›Intent‹ und veranlasst das System,
die Komponente zu aktivieren.
3.2 Die Android-Manifest-Datei
Damit das Android-System eine Applikation starten kann, muss es natürlich
zunächst einmal wissen, welche Dateien und Komponenten zu dieser
Applikation gehören. Zu diesem Zweck gibt es die Datei AndroidManifest.
xml. Diese Datei muss im Hauptverzeichnis des Projektes zu finden sein
und in ihr müssen alle Komponenten der Applikation deklariert werden.
Neben diesen stehen in dieser Datei noch einige andere Informationen, wie
z. B. der verwendete API-Level und die Rechte, welche die Applikation benötigt.
Ein Beispiel für eine Android-Manifest-Datei kann wie folgt aussehen.
22

3.2 Die Android-Manifest-Datei

Stichwortverzeichnis
A
ADT-Plugin 55
AlarmManager 97
AnalogClock 88
Android-User Interface 30
Android-Virtual Device 18
API 22, 23, 24, 25,
26, 156
Audioausgang 192
Audiogenerator 180
Audio-Recorder 193
B
Beschleunigung 155, 156, 158,
159, 166
Bitmap 134
BroadcastReceiver 93
C
Canvas 130
Chronometer 87, 88
CSS 242
D
Datenbank 217
DigitalClock 89
drawText() 133
DrawView 129
E
Eclipse 16
254
Environment.getExternalStorage-
State() 105
event 126, 131, 132, 159
Extended Markup Language 31
F
finish() 185
FTP 201
G
GPS 118
gpx-Format 149
GPX-Standard 155
gravity 88
H
HTML 242
I
Intent 85
Internet 204
J
JAVA-Development-Kit 16
Javascript 242
K
Kernel 10
Klinkenstecker 191, 192

Kommandozeile 234
Kurvenform 183
L
Layout 56
LED 100
Lesezugriff 105
Linux 233
ListView 68
LocationManager 122
LocationService 122
M
MediaPlayer 212
Mikrofoneingang 192
MySQL 216
N
Namespace 55
Network 232
NMEA 126
Notification 100
O
onClick 65
OnClickListener 63
onCreate 52
onLocationChanged() 123
onReceive() 97
onSensorChanged() 158, 159,
163
onTouchListener 130
Open Handset Alliance 9
P
Paint 130
PHP 220
Port 232
Projektbaum 52
Prozess 236
Q
Quick Fix 104
R
Receiver 115
Root 233
Runtime 236
Stichwortverzeichnis
S
SD-Karte 149
Sensoren 155, 156, 158, 159,
166, 167
setContentView() 30
Shell 236
Sinuskurve 183
SMS 114
Socketverbindung 227
Software Development Kit 16
Software Stack 10
Speicherkarte 102
SQL 217
startActivity 85
Stream 236
strings.xml 55
Superuser 233
System 233
Systeminformationen 236
255

Stichwortverzeichnis
T
Taktfrequenz 234
TELNET 125, 232
TextSize 87
Thread 186
TimePicker 93
Tonerzeugung 180
V
Verzeichnis 236
Vibrationsalarm 95
Video 209
256
VideoView 208
W
Webcam 201
WebView 212
Wegpunkt 154
Wiki 212
X
XML-Header 55

Stefan Schwark
Android
Apps programmieren – Schritt für Schritt
Smartphones und Tablet-Computer mit dem Betriebssystem Android fi nden immer weitere
Verbreitung. Die Anzahl der Anwendungsprogramme – die sogenannten Applikationen
oder kurz Apps – mit denen sich die Geräte individuell an die Vorlieben und Wünsche
ihrer Benutzer anpassen lassen, steigt täglich an. Die ständig besser werdende technische
Ausstattung der Geräte erlaubt inzwischen Anwendungen, die vor wenigen Jahren
nur Desktop-Computern oder spezieller Hardware vorbehalten waren. Mittlerweile kann
jedes Smartphone seine Position bestimmen, Videos aufnehmen und vieles andere.
Man ist bei der Individualisierung seines Smartphones aber nicht auf fi x und fertige Applikationen
beschränkt. Es ist einfacher als man denkt, Android-Geräte selber zu programmieren
und eigene Apps zu schreiben.
Dieses Buch bietet eine Einführung in die Programmierung von Apps auf Android-Geräten.
Es erklärt leicht nachvollziehbar die Funktionsweise des Android-Systems und Schritt für
Schritt die Programmierung von Applikationen.
Anhand vieler Beispiele werden die verschiedensten Anwendungsmöglichkeiten gezeigt.
Das reicht von einfachen Rechenprogrammen über die Abfrage von Sensoren und GPS-
Daten bis zur Programmierung von Applikationen für die Internet-Kommunikation. Neben
der Erstellung von Applikationen in der Programmiersprache JAVA wird auch gezeigt, wie
Apps mit Hilfe von Javascript oder PHP-Skripten programmiert werden können.
ISBN 978-3-89576-252-9
Elektor-Verlag GmbH
52072 Aachen
www.elektor.de