Seminararbeit - Android-App zur Bilddarstellung - RWTH

Fachhochschule Aachen
Campus Jülich
Fachbereich 9 – Medizintechnik und Technomathematik
Seminararbeit
im Studiengang Scientific Programming
Android-App zur Bilddarstellung
Eingereicht von
Marco Mix
Matrikel-Nummer: 836746
1. Prüfer: Prof. Dr. rer. nat. Bodo Kraft
2. Prüfer: Rainer Schnitzler
Aachen den 03. Januar 2012
Inhaltsverzeichnis
1. Motivation der Seminararbeit.............................................................................. - 1 2. Android ............................................................................................................... - 2 2.1 Was ist Android? ........................................................................................... - 2 2.2 Architektur von Android................................................................................. - 4 2.2.1 Die Dalvik Virtual Machine...................................................................... - 5 2.2.2 Standardbibliotheken.............................................................................. - 6 2.2.3 Anwendungsrahmen............................................................................... - 6 2.2.4 Anwendungsschicht................................................................................ - 6 2.3 Elemente einer Anwendung .......................................................................... - 7 2.3.1 Android-Komponenten............................................................................ - 7 2.3.2 Activity .................................................................................................... - 8 2.3.2.1 Views ............................................................................................... - 9 2.3.2.2 Layouts ............................................................................................ - 9 2.3.2.3 Menüs ............................................................................................ - 12 2.3.3 Android-Manifest .................................................................................. - 12 3. ZooAppSeminar................................................................................................ - 14 3.1 Activities der Zoo-App ................................................................................. - 14 3.1.1 ZooMainActivity .................................................................................... - 15 3.1.1.1 ImageZoomView ............................................................................ - 16 3.1.2 ZooInfo ................................................................................................. - 16 3.1.3 GehegeListe ......................................................................................... - 17 3.1.4 PinguinInfo ........................................................................................... - 18 3.1.5 PinguinGallery ...................................................................................... - 18 3.2 Navigation der Zoo-App .............................................................................. - 19 4. Fazit.................................................................................................................. - 23 5. Literaturverzeichnis........................................................................................... - 24 6. Abbildungsverzeichnis ...................................................................................... - 25 7. Eidesstattliche Erklärung .................................................................................. - 26 -
1. Motivation der Seminararbeit
In Zoos und Tierparks kann es leicht passieren, dass man sich nicht entscheiden
kann, welchen Weg man nehmen soll. Will man zuerst zum Affengehege oder doch
lieber zu den Elefanten? Und was wäre eine gute Route, um möglichst alle Gehege
zu Gesicht zu bekommen? Natürlich kann man auf Übersichtstafeln oder Flyer
zurückgreifen. Diese sind jedoch in vielen Zoos nur spärlich angebracht und
enthalten keine detaillierten Informationen über die einzelnen Gehege.
Bei der heutigen und für die Zukunft zu erwartenden Smartphone-Versorgungsdichte
ist es nahe liegend, darüber nachzudenken, eine Anwendung für diese Geräte zu
programmieren, welches die Aufgaben einer Übersichtskarte des Zoos und einer
Info-Tafel zu einzelnen Gehegen erfüllt.
Im Rahmen der bevorstehenden Bachelorarbeit wird dieses Programm als
Applikation für Android entwickelt. Die „Zoo-App“ soll eine Übersichtskarte des Zoos
(bzw. Tierparks) darstellen und die aktuelle Position hervorheben. Außerdem sollen
die Gehege auf der Karte anwählbar sein, um Bilder und detaillierte Informationen
über die dort lebenden Tiere erhalten zu können. So hat der Zoo-Besucher von
überall die Möglichkeit, sich einen guten Überblick zu beschaffen. Zusätzlich wird
noch ein Editor programmiert, mit dessen Hilfe Zoobetreiber die benötigten Daten für
die Applikation selber erstellen können. Im Zuge der Seminararbeit wurde eine
Vorstufe dieser Anwendung erstellt.
In dieser Seminararbeit wird die programmierte Anwendung vorgestellt und ihre
Aufgaben werden detailliert erläutert. Bevor auf die Anwendung eingegangen wird,
beschäftigt sich diese Arbeit näher mit dem Betriebssystem Android. Dabei wird
erklärt was genau Android ist, wie es aufgebaut ist und welche Komponenten zu
einer in Android programmierten Anwendung gehören.
-1-
2. Android
2.1 Was ist Android?
Die Firma Android wurde im Herbst 2003 gegründet und hatte sich auf die
Entwicklung von standortbezogenen Diensten für Mobiltelefone spezialisiert. Im
Sommer 2005 wurde die Firma dann von dem Unternehmen Google aufgekauft. Bis
dahin war Android nur Wenigen bekannt.
Am 5. November 2007 wurde dann von Google und 33 weiteren Mitgliedern aus
verschiedensten Branchen die Open Handset Alliance gegründet. Dazu gehörten
Netzbetreiber, wie T-Mobile, Softwarefirmen, wie zum Beispiel eBay, MarketingUnternehmen, Chiphersteller und die Gerätehersteller HTC, LG, Motorola und
Samsung. Somit waren Firmen aus allen Branchen beteiligt, die zur Entwicklung
eines mobilen Betriebssystems benötigt werden. Heute zählt das Konsortium 84
Mitglieder.
Am
Tag
der
Gründung
kündigten
sie
die
Entwicklung
eines
Betriebssystems für mobile Geräte unter dem Namen Android an. Es ist das
Hauptprodukt der Open Handset Alliance und kommt heute bei Smartphones,
Mobiltelefonen, Netbooks und Tablets zum Einsatz. Seit Oktober 2008 ist mit dem TMobile G1 das erste Android-Gerät offiziell im Handel.
Was Android für Gerätehersteller so interessant macht ist, dass es sich um eine freie
und quelloffene Software handelt. Jeder Hersteller kann Android somit kostenlos auf
seinen Geräten betreiben und an die eigenen Vorstellungen anpassen. So liefern
zum Beispiel HTC und Samsung ihre Android-Geräte fast ausschließlich mit der
eigenen Bedienoberfläche Sense bzw. TouchWiz aus. Diese hohe Anpassbarkeit
und die gebührenfreie Verwendung führt zu einem großen Interesse der Hersteller.
Folglich werden viele Geräte mit Android produziert und auf den Markt gebracht.
Allein der Hersteller Samsung hat schon ein Aufgebot von über 30 verschiedene
Android-Smartphones im Handel. Bei dieser Vielfalt an Geräten ist für den
Konsumenten die Chance groß eines zu finden, welches seinen Vorstellungen und
seiner Preisklasse entspricht. Ein weiterer positiver Aspekt für den Konsumenten ist
das große Angebot an Applikationen im Android Market. Der Android Market ist mit
mehr als 580.000 Anwendungen [Stand: November 2011] nicht nur die größte
Market-Software, sondern mit monatlich etwa 40.000 neuen Applikationen auch die
am schnellsten wachsende. Außerdem wurde im Dezember 2011 die Zahl von 10
-2-
Milliarden App-Downloads erreicht. Dies gibt dem Kunden die Möglichkeit, das
Smartphone an seine individuellen Bedürfnisse anzupassen.
Das Betriebssystem Android hat sehr gute Zukunftsaussichten. Im dritten Quartal
2011 lagen die Anteile an neu verkauften Smartphones laut Marktforschungsunternehmen Gartner bei 52,5%. Damit hat Android seine Marktanteile bei neu
verkauften Geräten im Vergleich zum Vorjahresquartal (25,3%) mehr als verdoppelt.
Insgesamt kann Google seit November 2011 über 200 Millionen aktivierte AndroidGeräte vorweisen und nähert sich langsam den 250 Millionen iOS-Geräten von
Apple.
Auch für Entwickler ist Android sehr interessant. Im Vergleich zu Apples „App Store“
ist die Programmierung und Bereitstellung von Anwendungen bei Android kostenlos.
Um Anwendungen für den „App Store“ programmieren zu können, muss man sich
bei Apple als Entwickler eintragen lassen und einen Jahresbeitrag von 99$ zahlen.
Programmiert werden die Android-Anwendungen ausschließlich in Java und sie
greifen
nur
bei
geschwindigkeitskritischen
Bereichen,
wie
Datenbank-
und
Webzugriffe, auf in C oder C++ geschriebene Basisbibliotheken zurück. Die
kostenfreie Programmierung in Kombination mit Java als Programmiersprache macht
die Entwicklung für Android sehr einsteigerfreundlich. Um eigene Anwendungen zu
programmieren, braucht man lediglich ein aktuelles Java-SDK und zusätzlich das
Android-SDK. Letzteres wird kostenlos bei http://developer.android.com/index.html
zur Verfügung gestellt. Mithilfe des mitgelieferten Emulators kann man die eigenen
Anwendungen direkt testen und die Notwendigkeit eines eigenen Endgerätes entfällt.
Ebenfalls sehr hilfreich für den Entwickler sind die gut dokumentierten APIs und das
umfangreiche Angebot von Code-Beispielen und Tutorials im Netz. Ein Nachteil bei
Android ist, dass die Anwendungen anders als bei Apple, keiner Überprüfung
unterzogen werden. Dadurch ist das Betriebssystem anfälliger gegen Schadsoftware.
Mit den steigenden Marktanteilen sind auch die Angriffe auf Android-Handys
sprunghaft angestiegen. So war Android im Oktober 2011 mit etwa 46% auf Platz 1
der meist attackierten Mobile-Systeme.
Im folgenden Abschnitt wird zuerst der Aufbau von Android näher beschrieben und
im Anschluss daran die programmierte Anwendung vorgestellt.
-3-
2.2 Architektur von Android
Das Betriebssystems Android basiert auf einer 4-Schichten-Architektur. Die Basis
bildet
der
Linux-Kernel
2.6,
der
in
Bezug
auf
Speichermanagment
und
Energieverbrauch optimiert worden ist. Er ist für die Speicherverwaltung,
Prozessverwaltung,
Multitasking
und
Netzwerkkommunikation
verantwortlich.
Außerdem enthält er die erforderlichen Gerätetreiber des Systems und dient als
Hardwareabstraktionsschicht für die Software. Ebene 2 bilden die AndroidLaufzeitumgebung und die Standardbibliotheken. Die Laufzeitumgebung beinhaltet
einen Hauptbestandteil der Android-Plattform, die Dalvik Virtual Machine (DVM). Bei
den Standardbibliotheken handelt es sich um C/C++-Bibliotheken. Sie stellen dem
Anwendungsrahmen (Ebene 3) die benötigten Funktionalitäten zum Betrieb von
Android-Anwendungen bereit. Der Anwendungsrahmen setzt sich aus in Java
geschriebenen Systemklassen zusammen. Diese Klassen ermöglichen es, aus
Anwendungen heraus auf Hardwarekomponenten zuzugreifen. So kann zum Beispiel
mit dem „Location Manager“ die aktuelle GPS-Position abgefragt werden. Die
oberste Ebene ist die Anwendungsschicht. Sie steht für alle auf dem Gerät
installierten Anwendungen. Dabei kann es sich um bereits vom Hersteller
vorinstallierte oder selbst programmierte bzw. heruntergeladene Anwendungen
handeln.
Abbildung 1 - Die Android-Systemarchitekur
-4-
2.2.1 Die Dalvik Virtual Machine
Die Dalvik Virtual Machine (DVM) ist eine, auf der Java Virtual Machine (JVM)
basierende, virtuelle Registermaschine. Sie wurde vom Google-Mitarbeiter Dan
Bornstein speziell für die Android-Plattform entwickelt. Während der Laufzeit führt die
DVM den zur Entwicklungszeit erzeugten Dalvik-Bytecode aus. Dieser Vorgang wird
in Abbildung 2 skizziert. Bei der Kompilierung des Programms wird vom JavaCompiler Java-Bytecode (*.class) erzeugt. Im zweiten Schritt kommt das im Android
SDK enthaltende Programm dx zum Einsatz. Es übersetzt den Java-Bytecode in den
Dalvik-Bytecode. Dabei werden mehrere .class-Dateien zu einer .dex-Datei
zusammengefügt und in Bezug auf den Speicherbedarf optimiert. Dieser Vorgang
wird auch Cross-Compiling genannt und ist für den Entwickler meist unsichtbar.
Abbildung 2 - Von *.java zu *.dex
Jede Android-Anwendung läuft in einer eigenen DVM, die für diese Anwendung
gestartet wurde. Dies hat den Vorteil, dass Abstürze nur die Anwendung selber
beenden und nicht das komplette System beeinflussen. Außerdem sind die Daten
einer Anwendung vor Zugriffen von außerhalb geschützt.
Ein weiterer Unterschied der DVM zur Java Virtual Machine ist die Nutzung von
Registern. Als Register bezeichnet man Zwischenspeicher, der sich direkt im
Mikroprozessor befindet. Er kann Berechnungen, die mehrere Zwischenschritte
brauchen, stark beschleunigen. Somit nutzt die DVM die Möglichkeiten der
heutzutage in den meisten Smartphones verbauten Prozessoren gut aus.
-5-
2.2.2 Standardbibliotheken
Bei den Standardbibliotheken handelt es sich um C/C++-Bibliotheken. Sie stellen die
Kernfunktionalitäten von Android bereit. Da es sich bei diesen Funktionalitäten oft um
geschwindigkeitskritische Bereiche handelt, sind die Bibliotheken nicht in Java
geschrieben, sondern mit den schnelleren Sprachen C bzw. C++ programmiert. Zu
diesen Bereichen zählen unter anderem Datenbanken (SQLite), MultimediaVerwaltung (Media-Framework), Web-Zugriffe (Webkit) und Grafik. Mithilfe von
Methoden dieser Bibliotheken kann der Entwickler die benötigten Funktionen in seine
Anwendung einbauen.
2.2.3 Anwendungsrahmen
Der
Anwedungsrahmen
setzt
sich
aus
komplett
in
Java
geschriebenen
Systemklassen zusammen. Diese Klassen werden auch Manager-Klassen genannt
und bilden den Grundstein einer jeden Anwendung. Sie dienen unter anderem zur
Hardwareabstraktion gegenüber dem Entwickler. Ein Beispiel einer solchen
Manager-Klasse ist der Location Manager. Mit ihm kann der aktuelle, geografische
Standort des Geräts bestimmt werden. Dieser Manager wird im weiteren Verlauf
dieser Arbeit noch mal aufgegriffen. Ein anderes Beispiel ist der Notification
Manager, der es einer Anwendung ermöglicht, Informationen in der Statusleiste des
Geräts
anzuzeigen.
Weitere
Manager-Klassen
und
Elemente
des
Anwendungsrahmens lassen sich aus Abbildung 1 entnehmen.
2.2.4 Anwendungsschicht
In der Anwendungsschicht befinden sich alle auf dem Gerät installierten
Anwendungen. Es kann sich dabei um bereits vom Hersteller vorinstallierte Apps, wie
Contacts und Phone, oder um selbst programmierte bzw. von Drittanbietern
erworbene Anwendungen handeln. Diese Schicht ist für den Android-Anwender
sichtbar und in ihr findet die Kommunikation zwischen Anwender und Anwendung
statt.
-6-
2.3 Elemente einer Anwendung
Dieses Kapitel beschäftigt sich, wie der Name schon sagt, mit den Elementen, aus
denen sich eine Android-Anwendung zusammensetzt. Dabei werden einige Punkte
nur kurz dargestellt.
2.3.1 Android-Komponenten
Ein Android-Programm setzt sich neben den allgemeinen Java-Klassen aus vier
Kernkomponenten zusammen. Es ist dabei nicht verpflichtend, dass jedes Programm
von allen vier zentralen Komponenten Gebrauch macht.
•
Activity
Activities
implementieren
die
sichtbaren
Bestandteile
einer
Anwendung und interagieren mit dem Anwender. In Kapitel 2.3.2 wird auf
diese Komponente nochmal detaillierter eingegangen.
•
Service Ein Service ist eine Komponente für Hintergrundoperationen. Er
besitzt keine Oberfläche, weil er nur im Hintergrund läuft. Um dies zu
verdeutlichen, kann man einen Musik-Player als Beispiel heranziehen. Die
Bedienung des Players kann man über eine Activity implementieren und das
eigentliche Abspielen der Musik einem Service überlassen. So kann die Musik
auch dann noch dann weiter abgespielt werden, wenn die Bedienoberfläche
geschlossen ist. Es gibt zwei Arten von Services: Local Service und Remote
Service. Als Local Service bezeichnet man einen Service, der im selben
Prozess wie die ihn startende Anwendung läuft. Ein Remote Service hingegen
läuft in seinem eigenen Prozess. Das hat den Vorteil, dass die Stabilität der
gesamten Anwendung erhöht wird. Außerdem bekommt der Remote Service
seinen eigenen Speicherbereich zugewiesen. Dies kann bei speicherintensiven Services sinnvoll sein.
•
Content Provider Die Aufgabe des Content Providers ist es, strukturierte
Datenmengen
(Datenbankinhalten)
und
Dateien
über
die
Anwendungsgrenzen hinaus zu veröffentlichen und zu verwalten. Dabei
werden stets nur die Inhalte und nie die Dateien bzw. Datenbanken selbst
übergeben.
•
Broadcast Receiver Broadcast Receiver sind für das Empfangen von
Systemnachrichten (Broadcast Intents) zuständig. Broadcast Intents treten bei
bestimmten Systemereignissen auf. Zu diesen Ereignissen zählen ein
-7-
niedriger Akkustand oder Störungen der Netzwerk- oder GPS-Verbindung. Die
Intents werden vom Broadcast Receiver registriert und es kann innerhalb der
Anwendung auf sie reagiert werden.
2.3.2 Activity
Activities sind die für den Anwender sichtbaren Bestandteile des AndroidProgramms. Mithilfe von Oberflächenelementen, wie zum Beispiel Textfeldern,
Eingabefeldern oder Schaltflächen, kann der Anwender mit dem Programm
interagieren. Diese Elemente nennt man Views und sie können mit verschiedenen
Layouts auf dem Bildschirm angeordnet werden. Eine Anwendung kann durch
Kombination mehrerer Activities zu einem komplexen Programm verknüpft werden.
Dabei ist eine Activity immer nur für die Darstellung von genau einer Bildschirmseite
zuständig. Um Activities zu vernetzen, werden Intents benutzt. Intents ermöglichen
es dem Entwickler, eine Activity (oder auch einen Service) aus einer anderen heraus
zu starten. Bei Bedarf können auch Daten mitgeschickt werden, auf die die neue
Activity dann zugreifen kann. Wurde eine neue Activity gestartet, ist die alte nicht
mehr sichtbar. Sie wechselt automatisch in einen inaktiven Zustand. Dieser Zustand
ist Teil des Lebenszyklus einer Activity. In Abbildung 3 ist dieser Lebenszyklus grob
skizziert.
Abbildung 3 - Lebenszyklus einer Activity
Wie in der Abbildung dargestellt, werden beim Starten einer Activity die Methoden
onCreate(), onStart() und onResume() in dieser Reihenfolge aufgerufen. onCreate()
erstellt die Activity mit all ihren Views, aber erst nach dem Aufruf von onResume() ist
sie auch sichtbar. Wenn die Activity nur teilweise durch eine neue Activity (Activity 2)
verdeckt wird, wird die Methode onPause() aufgerufen. Wird sie jedoch von Activity 2
-8-
komplett überdeckt, wird sowohl onPause() als auch onStop() ausgeführt. Sollte
Activity 2 jetzt geschlossen werden, muss Activity 1 nicht wieder komplett neu erstellt
werden. Es werden die Methoden onRestart(), onStart() und onResume() ausgeführt
und sie ist wieder sichtbar. Nur wenn eine Activity komplett beendet werden soll wird
onDestroy() aufgerufen. Bei diesen Methoden handelt es sich um Callbacks, die
automatisch aufgerufen werden. Sie können überschrieben werden und es kann ein
eigenes Verhalten implementiert werden.
In den folgenden Unterkapiteln werden die Bestandteile einer Activity näher
beschrieben. Zu diesen Bestandteilen zählen Views, Layouts und Menüs.
2.3.2.1 Views
Views sind Oberflächenelemente, die in der Activity dargestellt werden. Davon gibt
es einige zur Auswahl, von denen nur die wichtigsten auflisten werden.
•
TextView:
Ein- oder mehrzeiliges Textfeld
•
EditText:
Formularfeld zur Texteingabe
•
Button:
Schaltfläche
•
ImageButton:
Schaltfläche in Form eines Bildes
•
ImageView:
Bild
•
CheckBox:
Ankreuzfeld
•
RadioGroup:
Menge von RadioButtons (Auswahlschalter)
•
Spinner:
Auswahlliste
•
DatePicker:
Auswahl von einem Datum
•
TimePicker:
Auswahl der Uhrzeit
2.3.2.2 Layouts
Diese Views können mithilfe von Layouts angeordnet werden. Die gängigsten
Layouts, von denen es auch eine Vielzahl gibt, sind folgende:
•
LinearLayout
Beim
LinearLayout
werden
die
Views
hintereinander
abgebildet. Dabei kann die Ausrichtung zu Beginn auf horizontal oder vertikal
gesetzt werden
•
TableLayout Hier werden die Views in einem Feld einer Tabelle angezeigt.
Die Tabelle kann dabei eine beliebige Größe haben.
-9-
•
FrameLayout Dieses Layout platziert die Views in der linken oberen Ecke des
Bildschirms. Im Gegensatz zu den bisher genannten Layouts können sich
Views hier überlagern. Das FrameLayout sollte jedoch nur zur Anzeige von
genau einem Element benutzt werden.
•
AbsoluteLayout
Das AbsoluteLayout gibt dem Entwickler die Möglichkeit
Oberflächenelemente pixelgenau auf dem Bildschirm zu positionieren. Da
jedoch bei der Vielzahl an Android-Geräten auch viele verschiedene
Bildschirmgrößen und Auflösungen im Umlauf sind, ist dieses Layout selten
sinnvoll einsetzbar. In Einzelfällen kann es aber nützlich oder gar notwendig
sein.
•
RelativeLayout Beim RelativeLayout können Oberflächenelemente relativ zu
den Bildschirmrändern, oder relativ zu anderen Views (z.B. unterhalb von
View x) dargestellt werden. Eine absolute Positionierung wie beim
AbsoluteLayout ist ebenfalls möglich.
Neben diesen reinen Layoutklassen existieren noch weitere, von ViewGroup
abgeleitete Klassen, die eine Mischung aus Layout- und View-Elementen sind. Diese
Konstrukte stellen fertige Komponenten für bestimmte Situationen zur Verfügung. So
gibt es zum Beispiel eine ListView zur Darstellung von Views in Listenform, eine
Gallery zur Implementierung einer Bildergalerie und die MapView zur Darstellung
einer Kartenansicht wie beispielsweise Google Maps.
Layouts und Views werden bei Android üblicherweise im XML-Format definiert. Zwar
könnte man dies auch über die entsprechenden Klassen direkt im Java-Code
machen, es ist aber nur in Einzelfällen zu empfehlen. Das XML-Format ist deutlich
lesbarer und der Java-Code wird durch die Definition in XML viel übersichtlicher.
Dazu kommt noch, dass das Werkzeug zur Oberflächengestaltung im Android-Plugin
XML-Code ausgibt. Abbildung 4 zeigt den Aufbau einer solchen XML-Datei. Hier
wurde ein Button mit der Aufschrift „Klick mich“ und ein TextView mit dem Text „Hello
World“ erstellt. Beide Views sind in einem LinearLayout vertikal angeordnet. Der
onClick-Event des Buttons wurde außerdem mit der Methode „getButtonClicked“
verbunden. Diese Methode muss jetzt im Java-Code der Activity implementiert
werden.
- 10 -
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World" >
</TextView>
<Button
android:id="@+id/button01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="getButtonClicked"
android:text="Klick mich" >
</Button>
</LinearLayout>
Abbildung 4 - Layout-Datei main.xml
Diese Layout-Datei main.xml kann jetzt beim Erstellen der Activity geladen werden.
Um dies kurz zu verdeutlichen, zeigt der Code in Abbildung 5 eine Activity
HelloWorld mit dem ihr zugewiesenen Layout main.xml. Außerdem wird die Methode
getButtonClicked() des Buttons implementiert. In diesem Beispiel wird die Activity
beim Klicken des Buttons geschlossen.
package helloworld.test;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
public class HelloWorld extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
public void getButtonClicked(View v) {
this.finish();
System.exit(0);
}
}
Abbildung 5 - Activity als Java-Datei HelloWorld.java
Wie die Activity nach dem Erstellen aussieht, kann man Abbildung 6 entnehmen.
- 11 -
Abbildung 6 - Die fertige Activity
2.3.2.3 Menüs
Das Menü ist ein weiterer Bestandteil einer Activity. Es gibt zwei Arten von Menüs,
das Optionsmenü und das Kontextmenü. Das Optionsmenü wird mit der Menü-Taste
des Handys geöffnet. Es erscheint am unteren Bildschirmrand. Während man das
Optionsmenü der kompletten Activity zuordnet, gehört das Kontextmenü zu einem
bestimmten Element der Activity.
So kann man für jedes Element ein eigenes
Kontextmenü erstellen, welches über einen langen Klick (Long-Click-Event) auf jenes
Element geöffnet wird. Ein Anwendungsgebiet des Kontextmenüs ist zum Beispiel
die Erklärung der Funktion eines Buttons.
2.3.3 Android-Manifest
Ein wichtiger bisher nicht erwähnter Bestandteil einer Anwendung ist das AndroidManifest. Es ist eine XML-Datei (AndroidManifest.xml), die im Wurzelverzeichnis der
Anwendung liegt. Sie wird beim Erstellen eines Projekts automatisch angelegt und
wird benötigt, um die Anwendung lauffähig zu machen. Das Manifest enthält neben
dem Package-Namen und der Versionsnummer der Anwendung noch den minimalen
Android-API-Level, unter dem die Anwendung laufen kann. Zusätzlich müssen alle in
der Anwendung verwendeten Komponenten, wie Activities und Services, eingetragen
werden. So werden sie dem System bekannt gemacht. Außerdem wird die Start- 12 -
Activity festgelegt. Will man in seiner Anwendung zum Beispiel auf die GPS-Daten
des Handys zugreifen oder Daten auf der SD-Karte speichern braucht man dazu
Berechtigungen. Diese werden als usespermissions bezeichnet und müssen
ebenfalls in das Manifest eingetragen werden. Abbildung 7 zeigt den typischen
Aufbau des Android-Manifests. Es handelt sich dabei um das Manifest zu der in
Abbildung 6 dargestellten Anwendung. Hier wird der Package-Name und die
Versionsnummer angegeben (1), die minimale SDK-Version genannt (2), die
HelloWorld-Activity bekannt gemacht (3) und als Start-Activity gesetzt (4). Aus
Demonstrationszwecken wird noch eine uses-permission eingetragen (5) die es der
Anwendung erlaubt, das Handy vibrieren zu lassen.
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="helloworld.test" (1)
android:versionCode="1"
android:versionName="1.0" > (1)
<uses-sdk android:minSdkVersion="8" /> (2)
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:label="@string/app_name" (3)
android:name=".HelloWorld" >
<intent-filter >
<action android:name="android.intent.action.MAIN" /> (4)
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
</application>
<uses-permission android:name="android.permission.VIBRATE" /> (5)
</manifest>
Abbildung 7 - AndroidManifest.xml
Das nächste Kapitel beschäftigt sich mit der Vorstufe der Zoo-App, die im Zuge der
Seminararbeit programmiert wurde („ZooAppSeminar“). Dabei wird weniger auf die
Programmierung eingegangen, sondern mehr Wert auf die Funktionen der
Anwendung und die Aufgaben der einzelnen Activities gelegt.
- 13 -
3. ZooAppSeminar
Die App wurde im Zuge der Seminararbeit programmiert und diente hauptsächlich
der Einarbeitung in die Programmierung für Android. Zusätzlich legt dieses
Programm den Grundstein für die endgültige Anwendung, die im Rahmen der
Bachelorarbeit entwickelt werden soll. Man kann bei dieser App also von einer
Vorabversion sprechen, welche die Basisfunktionen der fertigen Anwendung
implementiert. Die wichtigsten dieser Basisfunktionen sind die Darstellung der ZooKarte und das Anzeigen von Informationen über bestimmte Gehege. Diese Gehege
werden zusammen mit der aktuellen GPS-Position des Benutzers auf der Karte
angezeigt. Weitere Funktionen, wie zum Beispiel das Darstellen einer Bildergalerie
zu einem Gehege, werden im Verlauf dieses Kapitels noch genannt und näher
beschrieben.
3.1 Activities der Zoo-App
In diesem Unterkapitel der Arbeit werden die einzelnen Activities der Zoo-App
vorgestellt. Zuerst werden diese Activities hier aufgelistet, um einen guten Überblick
zu haben. Im weiteren Verlauf wird dann näher auf die einzelnen Activities
eingegangen.
•
ZooMainActivity: Startactivity; stellt die Karte des Zoos dar
•
ZooInfo:
Informationen über den Zoo (Öffnungszeiten usw.)
•
GehegeListe:
Auflistung aller Gehege / Tiere des Zoos
•
PinguinInfo:
Information über Pinguine
•
PinguinGallery:
Bildergalerie zu den Pinguinen
•
GehegeInfo:
Information über ein bestimmtes Gehege
•
GehegeGallery:
Bildergalerie des Geheges
- 14 -
3.1.1 ZooMainActivity
Abbildung 8 – Übersicht mit geöffnetem Menü
Abbildung 9 – GPS-Modus
Bei der Activity „ZooMainActivity“ handelt es sich um die Startactivity der
Anwendung. Sie ist das Herzstück der ganzen Zoo-App und über sie können die
anderen Activities angesteuert werden. Die „ZooMainActivity“ setzt sich aus einer
ImageZoomView, drei ImageButtons, einer TextView und einem Optionsmenü
zusammen. Bei der ImageZoomView handelt es sich um eine selbsterstellte, von
View abgeleitete Klasse. Die View kann Bilder darstellen. Die Besonderheit ist, dass
das Bild dabei gezoomt und verschoben werden kann. Dieser Klasse ist am Ende
von Kapitel 3.1.1 ein eigener Absatz gewidmet, da hier noch weitere Aspekte
dargestellt werden sollen. Von den drei ImageButtons repräsentieren zwei Gehege,
die sich im Zoo befinden. Der dritte ImageButton zeigt die aktuelle GPS-Position des
Geräts auf der Karte an. Er ist nur sichtbar, wenn sich die Anwendung im GPSModus befindet. Die TextView ist ebenfalls nur im GPS-Modus sichtbar. Sie gibt die
GPS-Koordinaten auf zwei Nachkommastellen gerundet an. Über das Menü kann
man in diesen Modus wechseln. Außerdem kann man über dieses, in Abbildung 8
gezeigte Menü, die Activities ZooInfo und GehegeListe öffnen. Wie die Navigation
zwischen den Activities genau funktioniert wird in Kapitel 3.2 noch näher erläutert.
- 15 -
Die ImageButtons befinden sich im Vordergrund der Karte. Um dies zu ermöglichen,
wurde bei der „ZooMainActivity“ das RelativeLayout (s. 2.3.2.2 Layouts) verwendet.
3.1.1.1 ImageZoomView
Wie weiter oben schon erwähnt, ist die ImageZoomView eine selbsterstellte Klasse
und wurde von der Android-Klasse View abgeleitet. Es handelt sich also um eine
sogenannte „Custom View“. Die Klasse ImageZoomView wurde zusammen mit den
Klassen zur Implementierung der Zoom- und Pan-Logik, von einem Entwicklerteam
des Herstellers Sony Ericsson programmiert. Der Mitarbeiter Andreas Agvard hat
dazu
ein
vierteiliges
Tutorial
erstellt
und
den
Code
veröffentlicht
(http://developer.sonyericsson.com/wp/2010/05/18/).
Die Besonderheit dieser Klasse ist, dass der Zoom und das Verschieben mit einem
Finger bedient werden können. Streicht man mit seinem Finger über das Bild kann
man es verschieben. Hält man den Finger vor dem Streichen länger auf dem
Touchscreen gedrückt wechselt man in den Zoom-Modus. So kann das Bild durch
vertikale Bewegungen gezoomt werden.
3.1.2 ZooInfo
Abbildung 10 - ZooInfo-Activity
Die ZooInfo-Activity stellt allgemeine Informationen über den Zoo dar. Es werden die
Öffnungszeiten des Zoos, des Zoo-Restaurants und der Attraktion Ponyreiten
- 16 -
angezeigt. Diese Informationen werden mithilfe von TextViews dargestellt und sind in
einem LinearLayout angeordnet.
3.1.3 GehegeListe
Abbildung 11 - GehegeListe-Activity
Die GehegeListe-Activity ist eine Übersicht über alle im Zoo existierenden Gehege.
Sie besteht aus einer ListView, die alle Gehege in Form von TextViews beinhaltet. In
dem jetzigen Stand des Programms besteht diese Liste nur aus den zwei Einträgen
„Elefant“ und „Pinguin“. Durch einen Klick auf ein Listenelement können die
Gehegeinformationen zu diesem Gehege aufgerufen werden.
- 17 -
3.1.4 PinguinInfo
Abbildung 12 - PinguinInfo-Activity
In der PinguinInfo-Activity werden Informationen zum Pinguin angezeigt. Diese
Informationen werden mit einer TextView dargestellt. Außerdem besitzt die Activity
noch einen ImageButton, mit dem die Bildergalerie zum Gehege geöffnet werden
kann. Die Activity „GehegeInfo“ sieht identisch aus und unterscheidet sich nur im
Inhalt der TextViews zur PinguinInfo-Activity. Deshalb wird hier auf eine genauere
Beschreibung von GehegeInfo verzichtet.
3.1.5 PinguinGallery
Abbildung 13 - PinguinGallery-Activity
- 18 -
Hierbei handelt es sich um eine Bildergalerie, welche von der PinguinInfo-Activity aus
geöffnet werden kann. Sie gehört zum Pinguingehege. In der oberen Hälfte des
Bildschirms befindet sich eine Gallery und darunter wird eine ImageView dargestellt.
Eine Gallery ist eine fertige Android-Darstellungskomponente, die eine Liste von
Bildern
horizontal
nebeneinander
darstellt.
Sie
enthält
alle
Bilder
des
Pinguingeheges. Das ausgewählte Bild wird vergrößert in der ImageView angezeigt.
Bei der weiter oben erwähnten Activity „GehegeGallery“ handelt es sich um eine sehr
ähnliche Activity. Sie enthält lediglich andere Bilder und es werden MP3-Dateien zum
Bild abgespielt.
3.2 Navigation der Zoo-App
In diesem Kapitel geht es um die Navigation der Zoo-App. Dabei ist nicht die
Navigation in Form einer Routenplanung gemeint, sondern die Navigation zwischen
den Activities bzw. Funktionen der Anwendung. Bevor diese Navigation beschrieben
wird, werden alle Funktionen der Anwendung genannt, kurz erläutert und mit einer ID
versehen, um die Zustandsdiagramme zur Navigation übersichtlicher zu halten.
Außerdem wird noch die zur Funktion gehörende Activity angegeben.
- 19 -
ID
Beschreibung
Die
Übersicht
Zookarte
Activity
wird
vollständig
auf
dem
Bildschirm dargestellt. Als Symbole sind nur
die Gehege zu sehen. Das gibt dem Anwender
ZooMainActivitiy
eine gute Übersicht über den Zoo
Die aktuelle GPS-Position wird als roter Punkt
auf der Karte markiert und sie wird auf diesen
GPS-Modus
Punkt zentriert und reingezoomt. Ändert sich ZooMainActivitiy
die Position wandert die Karte mit. (gute
Orientierung)
Die Öffnungszeiten des Zoos, des Zoo-
Zoo-Info
Restaurants und der Attraktion „Ponyreiten“ ZooInfo
werden angezeigt.
Gehegeliste
Gehege-Info
Gehegegalerie
Eine Liste, die alle Gehege bzw. Tiere des
Zoos enthält, wird dargestellt.
GehegeListe
Informationen über das ausgewählte Gehege GehegeInfo
bzw. Tier werden angezeigt.
PinguinInfo
Eine Bildergalerie mit allen Bildern zum GehegeGallery
Gehege bzw. Tier wird dargestellt.
PinguinGallery
Tabelle 1 - Funktionen der Anwendung
Um die Übergänge zwischen diesen Funktionen bzw. Activities darzustellen wurden
zwei Zustandsdiagramme erstellt (Abbildungen 14 und 15). Zur besseren Übersicht
wurden die Funktionen Übersicht und GPS-Modus in Abbildung 14 unter
ZooMainActivity zusammengefasst und in ein eigenes Zustandsdiagramm (Abbildung
15) ausgelagert.
Die Anwendung startet mit der Activity ZooMainActivity. Dort befindet man sich im
Übersichtsmodus. Die Karte ist komplett sichtbar und nur von den ImageButtons der
Gehege überdeckt. Von hier aus kann man zu verschiedenen Funktionen gelangen.
Klickt man auf einen der ImageButtons, wird die entsprechende Gehegeinformation
angezeigt, von der aus man wiederum zur zugehörigen Bildergalerie gelangen kann.
Drückt man die Menütaste des Geräts öffnet sich das Menü und man kann zwischen
GPS- und Übersichtsmodus wechseln oder die Activities GehegeListe bzw. ZooInfo
- 20 -
starten. Die Beschriftungen der Pfeile in den Zustandsdiagrammen, die mit „Menü:“
beginnen, stehen für das Drücken des entsprechenden Menüelements. Die Aktion
„Zurück-Button geklickt“ repräsentiert das Drücken der Zurück-Taste, die bei jedem
Android-Gerät vorhanden ist. Diese Aktion schließt die aktive Activity und die davor
offene wird wieder sichtbar. Befindet man sich in der ZooMainActivity, wird die
Anwendung über die Zurück-Taste geschlossen.
Abbildung 14 – Zustandsdiagramm 1
- 21 -
Abbildung 15 – Zustandsdiagramm 2
- 22 -
4. Fazit
Zum Abschluss dieser Arbeit lässt sich sagen, dass das mobile Betriebssystem
Android sehr gute Zukunftsaussichten hat. Es ist attraktiv für die Hersteller von
Endgeräten,
für
die
Programmierer
von
Anwendungen
und
wird
ständig
weiterentwickelt. Die daraus resultierende Vielfalt an Android-Geräten und –
Anwendungen macht Android auch für die Kunden zur einer ansprechenden
Alternative zu Apples iOS oder Microsofts Windows Phone 7.
Die für die Arbeit programmierte Anwendung „ZooAppSeminar“ deckte viele der
grundlegenden Möglichkeiten der Android-Programmierung ab und ist ein guter
Einstieg in die Materie. Außerdem legt die Anwendung den Grundstein für das im
Rahmen der Bachelorabeit zu entwickelnde Programm und wird dort weiter
ausgebaut.
- 23 -
5. Literaturverzeichnis
[1]
Arno Becker und Marcus Pant. Android 2 – Grundlagen und Programmierung.
dpunkt.verlag. 2010
[2]
Wikipedia. Android (Betriebssystem).
Webseite. 03.01.2012.
http://de.wikipedia.org/wiki/Android_(Betriebssystem)
[3]
Wikipedia. Android Market.
Webseite. 03.01.2012.
http://de.wikipedia.org/wiki/Android_Market
[4]
Wikipedia. Open Handset Alliance.
Webseite. 03.01.2012.
http://de.wikipedia.org/wiki/Open_Handset_Alliance
[5]
Open Handset Alliance. Alliance Members.
Webseite. 03.01.2012.
http://www.openhandsetalliance.com/oha_members.html
[6]
Heise Online. Marktforscher: Hälfte aller Smartphones setzt auf Android.
Webseite. 03.01.2012.
http://www.heise.de/newsticker/meldung/Marktforscher-Haelfte-allerSmartphones-setzt-auf-Android-1379467.html
[7]
Heise Online. Ein Android für alle Fälle.
Webseite. 03.01.2012.
http://www.heise.de/ct/artikel/Ein-Android-fuer-alle-Faelle-1013666.html
[8]
Android and Me. Updates, or lack thereof, on the Android Update Alliance.
Webseite. 03.01.2012.
http://androidandme.com/2011/08/news/updates-or-lack-thereof-on-theandroid-update-alliance/
[9]
WinFuture. Angriffe auf Android-Handys nehmen sprunghaft zu.
Webseite. 03.01.2012.
http://winfuture.de/news,66623.html
- 24 -
6. Abbildungsverzeichnis
Abbildung 1: Die Android-Systemarchitekur
entnommen aus [1]
Abbildung 2: Von *.java zu *.dex
entnommen aus [1]
Abbildung 3: Lebenszyklus einer Activity
entnommen aus [1]
- 25 -
7. Eidesstattliche Erklärung
Hiermit versichere ich, dass ich die Seminararbeit mit dem Thema „Android-App zur
Bilddarstellung“ selbstständig verfasst und keine anderen als die angegebenen
Quellen und Hilfsmittel benutzt habe, alle Ausführungen, die anderen Schriften
wörtlich oder sinngemäß entnommen wurden, kenntlich gemacht sind und die Arbeit
in gleicher oder ähnlicher Fassung noch nicht Bestandteil einer Studien- oder
Prüfungsleistung war.
Name: Marco Mix
Aachen, den 03.01.2012
_____________________
Unterschrift des Studenten
- 26 -