You are on page 1of 89

Diplomarbeit

Sven Mller
geb. am 07. Juli 1983 in Limburg an der Lahn

Entwicklung von Komponenten fr ein mobiles
Bro unter dem Betriebssystem Android

Technische Hochschule Mittelhessen
Fachbereich Elektro- und Informationstechnik
Studiengang Informations- und Kommunikationstechnik


Referent: Prof. Bernhard Endl
Korreferent: Prof. Dr.-Ing. Alexander Kls
Firma: Prisma Gesellschaft fr angewandte
Informatik mbH
Firmenbetreuer: Dipl.- Inform. (FH) Mike Bach



Datum: 01.10.2012

II

Zusammenfassung

Das Ziel dieser Diplomarbeit war, eine Software zu entwickeln, die die Funktionen
eines mobilen Bros beinhaltet. Zu diesem Zweck soll es mglich sein, wichtige
Informationen ber einen Kunden fr den Aueneinsatz (beispielsweise im
Vertrieb) mobil auf einem Tablet
1
zur Verfgung zu haben. Dazu zhlen
Informationen wie Name, Adresse, Telefonnummer, etc. des Kunden sowie eine
Kontakthistorie, die Aufschluss darber gibt wann und wie mit dem jeweiligen
Kunden in Kontakt getreten wurde. Zustzlich sollen ber die Kontakthistorie alle
Dokumente wie z.B. Gesprchsprotokolle, Besuchsberichte, Rechnungen,
Angebote oder auch E-Mails, die durch die Kommunikation mit dem Kunden
entstanden sind, zur Verfgung stehen. Die fertige Software war so zu entwickeln,
dass sie unabhngig von einer dauerhaften Internetverbindung genutzt werden
kann. Um diesen Komfort zu erreichen, muss auf den mobilen Endgerten eine
eigene Datenbank implementiert werden, die es erlaubt auch unterwegs wichtige
Daten zu protokollieren und diese mit einer zentralen Stelle zu synchronisieren,
sobald wieder eine Internetverbindung besteht.
Die in dieser Diplomarbeit erfolgreich entwickelte Applikation fr das mobile
Betriebssystem Android ist in der Lage, Daten mit dem von der Firma Prisma
GmbH entwickelten Informationsmanagementsystem UpToNet

zu
synchronisieren. Des Weiteren knnen neue Datenstze angelegt und auf
Wunsch in das UpToNet

bertragen werden. Alle synchronisierten und selbst


erzeugten Daten werden in einer Datenbank abgespeichert und in einer grafischen
Benutzeroberflche bersichtlich dargestellt.



1
Begriffsdefinition Tablet siehe Glossar
III

Danksagung

Ich mchte mich hiermit bei allen bedanken, die mir bei der Erstellung di eser
Diplomarbeit geholfen haben.
Insbesondere gilt mein Dank meinem Betreuer Dipl.- Informatiker Mike Bach, der
mir jederzeit mit Rat und Tat zur Seite stand und immer ein offenes Ohr fr Fragen
jeglicher Art hatte.
Weiterhin mchte ich mich bei Herrn Professor Endl bedanken, der mich seitens
der THM immer freundlich und tatkrftig beraten hat und mich mit zahlreichen
Tipps und Anregungen bei der Bearbeitung dieser Diplomarbeit untersttzte.
Zum Schluss noch eine Danksagung an alle Mitarbeiter der Prisma GmbH fr das
nette, angenehme und freundschaftliche Betriebsklima, welches mir die
Durchfhrung dieser Diplomarbeit sehr erleichtert hat.

IV

Eidesstattliche Erklrung

Hiermit erklre ich, Sven Mller, geboren am 07.07.1983, dass ich die vorliegende
Diplomarbeit selbststndig angefertigt habe. Es wurden nur die in der Arbeit
ausdrcklich benannten Quellen und Hilfsmittel benutzt. Wrtlich oder sinngem
bernommenes Gedankengut habe ich als solches kenntlich gemacht.
Die Arbeit wurde bisher in gleicher oder hnlicher Form keiner anderen
Prfungsbehrde vorgelegt und auch nicht verffentlicht.

..
Ort, Datum Unterschrift

V

Abbildungsverzeichnis

Abb 1. Tablet-Computer .......................................................................................... 1
Abb 2. berblick der weltweit installierten Android-Betriebssysteme. ..................... 4
Abb 3. Android Schichtenmodell ............................................................................. 5
Abb 4. Grafische Darstellung unterschiedlicher Activitys ........................................ 6
Abb 5. bergnge und Zustnde der Activitys ........................................................ 8
Abb 6. Applikationsaufbau ...................................................................................... 9
Abb 7. Start-Activity ............................................................................................... 10
Abb 8. Eine Zeile der Kontaktansicht Liste ............................................................ 11
Abb 9. Kundenakten-Activity ................................................................................. 12
Abb 10. Kontakthistorie-Activity............................................................................. 14
Abb 11. Neuer Kontakt-Activity ............................................................................. 15
Abb 12. Einstellungen-Activity ............................................................................... 16
Abb 13. Tablet mit zweigeteilter Ansicht ............................................................... 17
Abb 14. Smartphone mit zwei Activitys zum Anzeigen der gleichen Informationen
wie auf einem Tablet ............................................................................... 18
Abb 15. Grafische Ansicht des Layouts aus Listing 1 ........................................... 19
Abb 16. Action Bar ................................................................................................ 19
Abb 17. Grafische Darstellung der Option-Buttons ............................................... 22
Abb 18. ListFragment mit individuellem Layout ..................................................... 23
Abb 19. Konzept des Model-View-Controllers ....................................................... 26
Abb 20. Steuerung der einzelnen Elemente durch die Activity .............................. 30
Abb 21. UpToNet

Cloud Modell ........................................................................... 32


Abb 22. Kontenverwaltung .................................................................................... 33
Abb 23. Starten der Synchronisation ..................................................................... 33
Abb 24. Ablaufplan der Synchronisation ............................................................... 35
Abb 25. Ablaufplan zum Synchronisieren von Daten aus der Cloud ..................... 37
Abb 26. Analyseablaufplan der Journal-Datei ....................................................... 41
Abb 27. Datenbankmodell der UpToNet

Mobile Datenbank ................................ 43


VI

Abkrzungsverzeichnis

ADT Android Development Tools
App Applikation
AVD Android Virtual Device
CRM Customer-Relationship-Management
(Kundenbeziehungsmanagement)
DMS Dokumentenmanagementsystem
dp Density-Independent Pixel
JDK Java Development Kit
JVM Java Virtual Machine
SDK Software Development Kit
SSL Secure Sockets Layer
Tab Tabbed Browsing (Registernavigation)
URI Uniform Resource Identifier
UUID Universally Unique Identifier
XML Extensible Markup Language

VII

Glossar

App Eine App als Kurzform fr Applikation bezeichnet im
Allgemeinen jede Form von Anwendungsprogramm. Im
heutigen Sprachgebrauch sind jedoch meistens Anwendungen
fr Smartphones und Tablets gemeint. Diese lassen sich mit
Hilfe eines, in das Betriebssystem integrierten Onlineshops
erwerben und installieren. Dadurch ist man in der Lage ein
Endgert mit beliebigen Zusatzfunktionen auszustatten und zu
erweitern
2
.
Cloud Unter Cloud (engl. fr Wolke) oder auch Cloud-Computing
wird ein Rechnernetzwerk bezeichnet, das onlinebasierte
Speicher- und Serverdienste zur Verfgung stellt. Die Idee
dahinter ist, dass Rechnerkapazitt, Datenspeicher,
Netzwerkkapazitt oder auch Software ber ein Netzwerk
(beispielsweise das Internet) zur Verfgung gestellt werden
3
.
Smartphone Ein Smartphone ist ein Mobiltelefon, dass mehr
Computerfunktionalitt als ein herkmmliches Mobiltelefon zur
Verfgung stellt. Aktuelle Smartphones lassen sich ber
Zusatzprogramme (Apps) vom Anwender individuell mit
zustzlichen Funktionen erweitern.
4

Tablet Ein Tablet oder auch Tablet-PC ist ein tragbarer, flacher
Computer mit einem Touchscreen-Display, das im Vergleich
zum Smartphone deutlich grer ist. Anders als ein Notebook
verfgen Tablets ber keine echte Maus und Tastatur sondern
lediglich ber ein virtuelle Tastatur, die je nach Bedarf ein- und
ausgeblendet wird. Aus diesem Grund erfolgt die Bedienung
ber den berhrungsempfindlichen Bildschirm mittels Finger
oder speziellem Eingabestift. Tablets lassen sich wie
Smartphones durch Apps individuell erweitern
5
.

2
Quelle: http://de.wikipedia.org/wiki/App (Stand 03.September 2012)
3
Quelle: http://de.wikipedia.org/wiki/Cloud-Computing (Stand 03.September 2012)
4
Quelle: http://de.wikipedia.org/wiki/Smartphone (Stand 03.September 2012)
5
Quelle: http://de.wikipedia.org/wiki/Tablet-Computer (Stand 03.September 2012)


Inhaltsverzeichnis
1 Einleitung ........................................................................................................ 1
2 Grundlagen ..................................................................................................... 3
2.1 Entwicklungswerkzeuge ............................................................................. 3
2.2 Auswahl der Android-Version ..................................................................... 3
2.3 Android Grundlagen ................................................................................... 5
2.3.1 Bestandteile einer Applikation ............................................................. 6
3 Vorstellung der Applikation ........................................................................... 8
3.1 Der Kreislauf der Activities ......................................................................... 8
3.2 Start-Activity ............................................................................................. 10
3.3 Activity: Kundenakten............................................................................... 12
3.4 Activity: Kontakthistorie ............................................................................ 14
3.5 Activity: Neuer Kontakt ............................................................................. 15
3.6 Activity: Einstellungen .............................................................................. 16
4 Die Benutzeroberflche softwaretechnische Aspekte ........................... 17
4.1 Das Layout der Activities .......................................................................... 17
4.2 Die Action Bar .......................................................................................... 19
4.2.1 Implementierung der Action Bar ........................................................ 20
4.2.2 Options Men .................................................................................... 21
4.3 Die Activity mit Daten fllen ..................................................................... 23
4.3.1 Die Klasse ListFragment ................................................................... 23
4.3.2 Implementierung der Klasse ListFragmentAnsprechpartner .............. 24
4.4 Reagieren auf Benutzereingaben ............................................................ 28
4.4.1 Das Prinzip der Listener .................................................................... 28
4.4.2 Listener registrieren ........................................................................... 28
4.4.3 Reagieren auf Benutzereingaben der Action Bar .............................. 30
5 Synchronisation der Daten .......................................................................... 32
5.1 Synchronisation mit Hilfe von Online-Konten ........................................... 32
5.2 Ablauf der Synchronisation ...................................................................... 34
5.3 Synchronisieren von Dokumenten ........................................................... 37


5.4 Synchronisieren von Datenbankeintrgen ............................................... 39
6 Datenspeicherung in Datenbanken ............................................................. 42
6.1 Content-Provider ...................................................................................... 45
6.2 Zugriff auf Datenbankinhalte .................................................................... 46
6.3 Das Konzept der Klasse LoaderManager ................................................ 47
6.4 Die Methode setViewBinder() ............................................................... 50
7 Fazit und Ausblick ........................................................................................ 51

1

1 Einleitung

Mobilitt ist heutzutage ein immer wichtiger werdendes Thema und auch
Smartphones
6
und Tablets rcken mehr und mehr in den Vordergrund. Waren zu
Beginn dieser ra Business-Apps
7
kaum ein Thema, so gewinnen sie auch im
geschftlichen Bereich immer mehr an Bedeutung. Dies liegt unter anderem an
der Handlichkeit, der hohen Akkulaufzeit
8
und der einfachen und intuitiven
Bedienung mittels Finger oder speziellem Eingabestift der mobilen Gerte. Zudem
steht die Rechenleistung moderner Endgerte einem Notebook in nichts mehr
nach.
Ein weiterer Vorteil, vor allem bei der Verwendung von einem Tablet in Gegenwart
eines Kunden, ist die geringe Barriere die durch ein solches Gert aufbaut wird.
Bei der Verwendung eines Notebooks in Gegenwart eines Kunden wird durch den
senkrecht stehenden Bildschirm oftmals eine Art von Sichtschutz aufgebaut,
wodurch eine gewisse Distanz zum Kunden entsteht. Bei der Verwendung eines
Tablets ist diese negative Eigenschaft nicht vorhanden. Die Bedienung des
Gertes gleicht eher einer Mitschrift auf einem Notizblock.
Nachteil solcher Gerte sind allerdings der im Gegensatz zum Notebook kleinere
Bildschirm und die virtuelle Tastatur, welche den darstellbaren Bereich beim
Schreiben einer Nachricht noch einmal zustzlich verkleinert.

Abb 1. Tablet-Computer

6
Begriffsdefinition Smartphone siehe Glossar
7
Begriffsdefinition App siehe Glossar
8
Aktuelle Gerte wie das Samsung Galaxy Tab oder das Apple iPad haben eine Akkulaufzeit von
ca. 8 Stunden beim Surfen im Internet. Quelle: http://www.test.de/Tablet-Rechner-Einer-besser-als-
das-iPad-4304701-0/ (Stand: 10.September 2012)

2

Die Diplomarbeit gliedert sich in drei grere Teilbereiche. Der erste Teil ist die
Entwicklung einer bersichtlichen, anwenderfreundlichen Benutzeroberflche. Teil
zwei umfasst die Entwicklung eines Synchronisationsmechanismus mit einem
Cloud-hnlichen
9
Dienst. Der letzte Teil befasst sich mit dem Speichern aller
relevanten Daten in einer auf dem Endgert befindlichen Datenbank.


9
Begriffsdefinition Cloud siehe Glossar

3

2 Grundlagen
Das folgende Kapitel erlutert die grundlegenden Elemente der Android-
Softwareentwicklung. Dazu werden zuerst die bentigten Entwicklungswerkzeuge
vorgestellt. Im Anschluss folgt ein berblick ber die verschiedenen Android-
Versionen, der Aufbau des Android-Betriebssystems sowie die wichtigsten
Bestandteile einer Android-Applikation.
2.1 Entwicklungswerkzeuge
Die wichtigste Grundlage bei der Softwareentwicklung unter Android ist das
Android SDK. Dieses stellt alle bentigten Bibliotheken zum Zugriff auf die
Laufzeitumgebung bereit. Zudem enthlt es einen eigenen Emulator fr jede
Android-Version, Treiber fr verschiedene Endgerte, Beispielanwendungen und
vieles mehr. Als Entwicklungsumgebung wurde Eclipse Indigo im Zusammenspiel
mit dem Java Development Kit (JDK) in der Version 1.6 Update 33 verwendet.
Zudem muss eine Version des ADT Plug-In fr Eclipse installiert sein. Mit diesem
ist es innerhalb von Eclipse mglich neue Android-Projekte anzulegen, diese zu
debuggen, eine Benutzeroberflche zu erstellen und das fertige Projekt zu
exportieren. Eine detaillierte Vorgehensweise zur Installation und Einrichtung der
Komponenten und dem Import des Quellcodes findet sich in Anhang A.
Als Entwicklungs- und Testgert wurde ein Motorola Xoom, anfnglich mit der
Android-Version 3.2, gegen Ende dieser Diplomarbeit nach einem Update mit der
Version 4.0.4 verwendet (Technische Daten zu diesem Gert befinden sich im
Anhang A).
2.2 Auswahl der Android-Version
Eine wichtige Frage, die man sich vor der Entwicklung einer Applikation (im
weiteren App genannt) unter dem Betriebssystem Android stellen muss, ist die
Frage, fr welches Endgert entwickelt werden soll. Bis zum 19. Oktober 2011
(Erscheinungsdatum von Android 4.0 Ice Cream Sandwich
10
) wurde noch
zwischen Android-Versionen unterschieden, die entweder nur fr Smartphones
(2.3.x Gingerbread) oder Tablets (3.x Honeycomb) geeignet waren. Mit der
Einfhrung von Ice Cream Sandwich (die unterschiedlichen Android-Versionen
werden immer nach einer Sspeise benannt) gibt es nun wieder eine Version,

10
Quelle: http://en.wikipedia.org/wiki/Android_version_history (Stand: 04.September 2012)

4

die nicht zwischen Tablets und Smartphones unterscheidet und fr beide Gerte
die gleichen Funktionen zur Verfgung stellt. Nun wre es aber ein Fehler, gleich
fr die neueste Android-Version zu entwickeln, da diese Applikationen nur auf
Gerten funktionieren wrden, die auch tatschlich die neueste
Betriebssystemversion installiert haben. In Abbildung 2 ist die Verteilung der
weltweit installierten Android-Betriebssysteme dargestellt. Anhand dieser kann
nun entschieden werden, womit man womglich die besten Verkaufszahlen
erzielen kann (In der Statistik werden nur Gerte aufgefhrt, die sich auf Google
Play eingeloggt haben).

Abb 2. berblick der weltweit installierten Android-Betriebssysteme
11

Als Entwicklungsversion wurde Android 3.2 Honeycomb gewhlt, da die fertige
Applikation vorerst ausschlielich auf Tablet-Computern lauffhig sein soll. Diese
ist zwar laut Abbildung 2 nur auf ca. 1,6% aller Gerte installiert, allerdings sind
alle Versionen aufwrtskompatibel, was bedeutet, dass die App auch auf allen
Gerten der Version 4.x und evtl. Nachfolgenden einsetzbar ist. Eine Neuerung,
die mit der Android-Version 4 eingefhrt wurde, ist die so genannte Support-
Library. Mit dieser ist es mglich, Komponenten, die fr eine hhere Android-
Version entwickelt wurden, auch auf Gerten mit einer niedrigeren Android-
Version auszufhren. Dadurch wird eine gewisse Abwrtskompatibilitt erreicht.

11
Quelle: http://developer.android.com/about/dashboards/index.html (Stand: 04.September 2012)

5

2.3 Android Grundlagen
Das Android-Betriebssystem basiert auf einem Linux-Kern. Linux ist ein fr
mehrere Benutzer ausgelegtes Betriebssystem (Multi-User-Kern). Es ist so
konzipiert, dass jeder Benutzer seine Aktionen in einem eigenen Prozess (Thread)
ausfhrt. Dies hat den Vorteil, dass bei einem fehlerhaften Prozess nur dieser neu
gestartet werden muss und alle anderen Benutzer ohne Einschrnkungen weiter
arbeiten knnen. Android ist zwar kein Multi-User-Betriebssystem, macht sich
dieses Konzept aber dennoch zu Nutze, indem jede Applikation einen eigenen
Benutzer simuliert und in einem eigenen Linux-Prozess ausgefhrt wird. Dadurch
wird das Betriebssystem sehr sicher gegenber Systemabstrzen, da jeweils nur
der fr den Fehler verantwortliche Prozess beendet werden muss.
Android basiert auf einem Vier-Schichtenmodell (siehe Abbildung 3)
12
, wobei die
Schichten Applications, Application-Framework und die Core-Libraries als
Dalvik-Bytecode auf der Dalvik Virtual Machine ausgefhrt werden. Der Linux-
Kern, die Libraries und die Dalvik Virtual Machine sind dagegen in C/C++
programmiert.

Abb 3. Android Schichtenmodell
Auf der untersten Schicht dieses Modells ist der Linux-Kern mit allen bentigten
Hardwaretreibern angesiedelt. Auf der zweiten Schicht befindet sich neben den

12
Quelle: http://source.android.com/tech/security/images/image00.png (Stand 09.September 2012)

6

Standard-Bibliotheken die Dalvik Virtual Machine
13
. Der erzeugte Bytecode einer
Applikation wird nicht von einer Java Virtual Machine (JVM) oder dem Prozessor
des Mobiltelefons / Tablets ausgefhrt, sondern von der Dalvik Virtual Machine,
die fr den Linux-Kern wie ein eigenes Programm erscheint. Die dritte Schicht
enthlt das sogenannte Application-Framework, welches das Programmiergerst
enthlt. Auf der obersten Schicht befinden sich die fr den Anwender sichtbaren
Applikationen.
2.3.1 Bestandteile einer Applikation
Im Grunde kann man eine Android-App in 3 Bestandteile zerlegen.
Zum einen gibt es eine Activity, die vereinfacht dargestellt eine Bildschirmseite auf
dem Tablet oder Smartphone darstellt (siehe Abbildung 4). Sie ist eine eigene
Java-Klasse und steuert u.a. die Funktionen der auf dem Bildschirm dargestellten
Elemente, ffnet Netzwerk- und Datenbankverbindungen und startet andere
Activitys.

Abb 4. Grafische Darstellung
14
unterschiedlicher Activitys

Als zweites existieren verschiedenste Ressourcendateien. Diese haben in Android
vielseitige Aufgaben. Sie knnen beispielsweise das Aussehen einer Activity

13
vgl: Knneth, Thomas(2012): Android 4-Apps entwickeln mit dem Android SDK, Bonn 2012, S.26
14
Quelle: http://developer.android.com/guide/topics/ui/index.html (Stand: 03.September 2012)

7

bestimmen, verschiedene Strings an einer zentralen Stelle sammeln (zum
leichteren bersetzen der App in andere Sprachen) oder Animationen festlegen.
Als letzten Bestandteil gibt es das so genannte Manifest. Dies ist eine besondere
Ressourcendatei, die wichtige Informationen zum Programm enthlt. Dort werden
alle Activitys aufgelistet, der Einstiegspunkt beim Starten der App festgelegt,
Hintergrundservices und Content-Provider deklariert oder Intent-Filter vergeben.
Letztere bestimmen, ob Funktionen des Programms auch anderen Anwendungen
zur Verfgung stehen sollen. Beispielsweise kann die gerteinterne Kamera-
Activity von jeder anderen Anwendung gestartet werden. Zustzlich mssen
innerhalb der Manifest-Datei alle von der Applikation verwendeten
Betriebssystem- und Laufzeitkomponenten ber sogenannte Permissions
(Berechtigungen) angegeben werden. Diese Berechtigungen werden bei der
Verffentlichung der Applikation in Google Play angezeigt und mssen vor der
Installation auf einem Endgert durch den Benutzer besttigt werden. Dabei ist es
nicht mglich nur einzelne Berechtigungen zu akzeptieren und andere nicht. Das
Konzept der Berechtigungen bietet dem Benutzer der Applikation eine gewisse
Sicherheit vor schadhafter Software bzw. Spionagesoftware. Mchte
beispielsweise eine Applikation zum Bearbeiten von Bildern eine Berechtigung fr
die Benutzung des Mikrofons oder zum Auslesen des Telefonbuchs, so ist dies
kritisch zu hinterfragen.
Da die Grundlagen der Android-Softwareentwicklung ein sehr umfangreiches
Themengebiet sind, befindet sich im Anhang A eine einfhrende Beschreibung
dieser Thematik. Diese umfasst den Aufbau der Projektstruktur, die Grundlagen
der Layout-Ressourcen und eine Beschreibung der Klassen Activity und
Fragment.



8

3 Vorstellung der Applikation
Zum besseren Verstndnis der nachfolgenden Kapitel werden in diesem Abschnitt
die einzelnen Komponenten der Applikation aufgezeigt und deren Zusammenspiel
untereinander erlutert.
3.1 Der Kreislauf der Activities
Die in der Diplomarbeit zu entwickelnde Applikation besteht aus insgesamt sechs
unterschiedlichen Activitys. Der Ablaufplan mit den jeweiligen bergngen und
Zustnden der Activitys ist in Abbildung 5 dargestellt.


Abb 5. bergnge und Zustnde der Activitys


9

In Abbildung 6 ist eine bersicht des Applikationsaufbaus mit dem
Zusammenspiel der Komponenten aus dem Android-Framework dargestellt.

Abb 6. Applikationsaufbau
Im folgenden Abschnitt wird die Benutzeroberflche im Hinblick auf die
entwickelten Activitys vorgestellt (aus Sicht des Benutzers). In Kapitel 4 hingegen
steht der softwaretechnische Aspekt bei der Entwicklung der Benutzeroberflche
im Vordergrund.

10

3.2 Start-Activity

Abb 7. Start-Activity
In Abbildung 7 ist die Start-Activity dargestellt, die sich zum Applikationsstart
ffnet.
Auf der Action Bar, die sich am oberen Bildschirmrand befindet, sind insgesamt
fnf Elemente vorhanden.
In dem orange umrandeten Bereich befindet sich das Applikations-Logo mit
zugehriger berschrift. Dieses ist innerhalb der Start-Activity nicht anklickbar und
erfllt an dieser Stelle keine weitere Funktion.
Rechts neben der berschrift befindet sich in dem lila umrandeten Feld eine
Funktionsleiste mit insgesamt drei Tabs. Diese erfllen zu diesem Zeitpunkt noch
keine wichtigen Funktionen. Mit einem Klick auf den Reiter UpToNet

Online
wird das Fragment, in dem sich die letzten Kontakte befinden, durch eine Web-
View ausgetauscht und die Homepage der Prisma GmbH geffnet. An dieser
Stelle soll in Zukunft das UpToNet

in einer Online-Version erscheinen und von


hier aus bedient werden knnen. Nach Auswahl des Reiters Kalender wird der
Standard-Kalender geffnet, der z. Z. nur als Platzhalter dient. In einer eventuellen

11

Weiterentwicklung soll es mglich sein, Termine aus dem UpToNet

zu
synchronisieren, die an dieser Stelle dargestellt werden sollen.
In dem dunkelblauen Bereich ist eine Suchleiste implementiert, mit der es mglich
ist, innerhalb der Firmenliste nach einer bestimmten Firma zu suchen. Die Suche
ist so realisiert, dass nach jedem neu eingegebenen bzw. gelschten Zeichen eine
neue Suche beginnt. Die Gro- und Kleinschreibung wird hierbei ignoriert. Zudem
ist es mglich, nur nach bestimmten Teilen eines Wortes zu suchen. Wird die
Firmenliste mit Hilfe der Suche auf weniger als 10 Eintrge reduziert, startet in der
Kontakthistorien-Liste (grn umrandet) ebenfalls eine Datenbankabfrage, nach der
nur noch Kontakte aufgelistet werden, die den gefilterten Firmen zugehrig sind.
Bei einem Klick auf das grau umrandete Icon wird eine Activity zum Anlegen von
neuen Kontakten gestartet (siehe Abbildung 11).
Das letzte Element auf der Action Bar ist das trkis umrandete Icon zum ffnen
der Einstellungen-Activity (siehe Abbildung 12).
Durch die Auswahl einer Firma in der Firmenliste (rot umrandeter Bereich) gelangt
man in die Kundenakten-Activity (siehe Abbildung 9).
Auf der rechten Seite des Bildschirms befindet sich die Kontakthistorie (grn
umrandeter Bereich). Hier werden alle Kontakte die auf dem Gert vorhanden sind
nach Datum sortiert angezeigt. Innerhalb einer Zeile der Kontakthistorie werden
folgende Informationen dargestellt:

Abb 8. Eine Zeile der Kontaktansicht Liste
Durch einen Klick auf einen Kontakt ffnet sich die Kontakthistorie-Activity (siehe
Abbildung 10).


12

3.3 Activity: Kundenakten

Abb 9. Kundenakten-Activity
In Abbildung 9 ist die Kundenakten-Activity dargestellt. Zu dieser gelangt man,
nachdem in der Start-Activity eine bestimmte Firma ausgewhlt wurde.
Auf der Action Bar befindet sich von links aus gesehen als erstes Element das
App-Logo. Dieses ist anklickbar und erfllt die gleiche Funktion wie der Zurck-
Button des Tablets.
Rechts neben dem App-Logo befindet sich die berschrift der Activity (dunkelblau
umrandet). Diese zeigt die momentan geffnete Firma an.
Innerhalb des gelb markierten Bereichs sind zwei Tabs vorhanden. Mit diesen wird
zwischen den Kontakten und den zugehrigen Anhngen gewechselt. Dazu wird
das Fenster, in dem alle Kontakte angezeigt werden, nach rechts aus dem
sichtbaren Bereich geschoben und durch ein neues Fenster, welches die Anhnge
anzeigt, ersetzt.
Im rechten Bereich der Action Bar befindet sich ein Suchfeld (schwarz umrandet),
mit dem innerhalb der Kontaktansicht nach einem bestimmten Datum, Betreff oder
Mitarbeiter gesucht werden kann.

13

Das letzte Element ist ein anklickbares Icon (hellblau umrandet), mit dem neue
Kontakte angelegt werden knnen (siehe Abbildung 11)
Unterhalb der Action Bar befinden sich drei unterschiedliche Bereiche. In dem lila
umrandeten Feld ist eine Ansprechpartnerbersicht dargestellt. Dies ist eine Liste
mit allen Ansprechpartnern einer bestimmten Firma. Dabei wird die Firma selbst
ebenfalls als Ansprechpartner angezeigt und befindet sich immer an erster Stelle
der Liste. In dem rot umrandeten Bereich befinden sich Details zu dem gewhlten
Ansprechpartner. Hier werden alle Zusatzinformationen wie Name, Adresse,
Telefonnummer, E-Mail und Webadresse dargestellt. Bei einem Klick auf einen als
Link markierten Eintrag wird eine zu diesen Daten passende Applikation gestartet.
Wurde beispielsweise die E-Mail Adresse ausgewhlt, wird eine Anwendung
gestartet, mit der es mglich ist E-Mails zu versenden (wenn eine solche
Anwendung auf dem Gert installiert ist). Bei Auswahl der Adresse wird diese in
Google Maps angezeigt. Eine Webadresse wird mit dem Standard-Browser des
Tablets geffnet.
Auf der rechten Seite des Bildschirms (innerhalb des hellgrn umrandeten
Bereichs) befindet sich die Kontaktansicht. Hier werden alle Kontakte eines
Ansprechpartners aufgelistet. Ist die Firma in der Ansprechpartnerbersicht
ausgewhlt, werden von allen Ansprechpartnern dieser Firma die Kontakte
angezeigt.
Nachdem ein bestimmter Kontakt ausgewhlt wurde, ffnet sich die
Kontakthistorie-Activity, in der weitere Details eines Kontaktes angezeigt werden
(siehe Abbildung 10). Mit einem langen Klick auf einen Kontakt ffnet sich ein
Kontextmen, in dem man die Mglichkeit hat einen Kontakt zu lschen und zu
bearbeiten.
Hinweis: Das Lschen ist aus Sicherheitsgrnden nur bei Kontakten mglich, die
innerhalb der App erzeugt und noch nicht synchronisiert wurden.

14

3.4 Activity: Kontakthistorie

Abb 10. Kontakthistorie-Activity
Die in Abbildung 10 dargestellte Kontakthistorie-Activity ist der Kundenakten-
Activity aus Abbildung 9 sehr hnlich. Die Action Bar ist in beiden Activitys
identisch und besitzt die gleichen Elemente und Funktionen. Das Fragment
Kontaktansicht (hellblau umrandet) ist das Gleiche wie in der Kundenakte, besitzt
lediglich eine andere Layout-Ressource und damit ein anderes Aussehen.
In dem schwarz umrandeten Bereich befinden sich Details zu dem in der
Kontaktansicht gewhlten Kontakt. Hier werden die Felder Kontaktart,
Kontaktrichtung, Anlage durch, Anlagedatum, Ansprechpartner, Mitarbeiter und
Betreff des Kontaktes dargestellt.
Unterhalb der Kontaktdetails befindet sich eine zoombare Web-View (hnlich
einem Browserfenster), in dem die Notizen zu einem Kontakt angezeigt werden.
An dieser Stelle knnen keine Informationen gendert oder ergnzt werden. Dies
ist ebenfalls nur ber einen langen Klick in der Kontaktansicht und anschlieender
Auswahl der Aktion im sich ffnenden Kontextmen mglich.


15

3.5 Activity: Neuer Kontakt

Abb 11. Neuer Kontakt-Activity
In Abbildung 11 ist der Dialog zum Anlegen und Bearbeiten von Kontakten
dargestellt. Im linken Bereich der Action Bar sind das Applikationslogo und eine
berschrift vorhanden. Mit einem Klick auf das Logo und anschlieendem
Besttigen einer Sicherheitsabfrage kann die Activity verlassen werden. Im
rechten Bereich der Action Bar hat man die Mglichkeit die Aktion abzubrechen
oder den Kontakt zu speichern, woraufhin dieser in die Datenbank geschrieben
wird. Das letzte Element ist ein anklickbares Icon, mit dem Anhnge zu dem
jeweiligen Kontakt erstellt werden knnen. Mit einem Klick auf dieses Icon wird die
Android-eigene Kameraanwendung gestartet, mit der Bilder aufgenommen werden
knnen. Die Idee dahinter ist, wichtige Dokumente oder Visitenkarten zu
scannen und mit einem Kontakt zu verknpfen.
Alle gescannten Dokumente werden in dem Feld Anhnge (grn umrandet)
angezeigt. Hier hat man die Mglichkeit durch einen langen Klick ein Kontextmen
zu ffnen, mit dem die Anhnge umbenannt oder gelscht werden knnen.
In dem rot markierten Bereich knnen alle wichtigen Angaben zu einem Kontakt
gemacht werden. Die Elemente Firma, Ansprechpartner, Mitarbeiter, Kontaktart
und Kontaktrichtung sind als Spinner (Drop-Down-Choice) realisiert. Je nach
ausgewhlter Firma ndern sich die in dem Spinner Ansprechpartner
angezeigten Eintrge. Bei den Feldern Betreff und Notizen handelt es sich um
mehrzeilige Eingabefelder, die ihre Gre an den eingegebenen Text anpassen.

16

3.6 Activity: Einstellungen

Abb 12. Einstellungen-Activity
In Abbildung 12 ist das Einstellungsmen der Applikation dargestellt. Hier hat man
die Mglichkeit die Download-URL und die Site-ID zu ndern.
Die Download-URL ist eine Webadresse, mit der die UpToNet-Cloud adressiert
wird. Bei der Site-ID handelt es sich um eine vierstellige Zahl, mit der man eine
Datenbank kennzeichnet. Die Idee dahinter ist, dass alle Daten aus dem
UpToNet

und den mobilen Gerten an einer zentralen Stelle innerhalb der Cloud
gesammelt werden. Dabei kennzeichnet jede Datenbank seine exportierten Daten
durch die eigene Site-ID. Bei der Synchronisation wird nun das Cloud-Verzeichnis
untersucht, in dem sich alle Dateien befinden. Im Anschluss werden nur diejenigen
Daten heruntergeladen und importiert, die nicht die eigene Site-ID besitzen und
nach dem letzten Synchronisationszeitpunkt erstellt wurden.

17

4 Die Benutzeroberflche softwaretechnische Aspekte
Das Ziel bei der Entwicklung der grafischen Benutzeroberflche war es, eine
mglichst bersichtliche, aber dennoch informative Darstellung zu erreichen. Dazu
stellt Android einige Hilfsmittel bereit, die im Folgenden nher beschrieben
werden. Dabei werden die softwaretechnischen Aspekte einer Layout-Ressource,
das Prinzip der Action Bar sowie die Implementierung eines ListFragments mit
anschlieender Reaktion auf eine Benutzereingabe erlutert.
4.1 Das Layout der Activities
Das Layout der Activities wurde mit Hilfe von Frame-Layouts und Fragmenten
aufgebaut (Eine nhere Beschreibung zu Fragmenten befindet sich im Anhang A).
Ein Framelayout ist einfach ausgedrckt ein Container, in den verschiedene
Elemente wie z. B. eine Draw-View oder ein List-Fragment eingesetzt werden
knnen. Ein Fragment ist eine eigene Java-Klasse, die genau wie eine Activity ein
eigenes Layout besitzt. Die Verwendung solcher Komponenten hat den Vorteil,
dass sich diese whrend der Laufzeit leicht gegen andere Elemente austauschen
lassen. Zudem ist es dadurch mglich, mit geringem Mehraufwand, die App auch
auf Smartphones einzusetzen. Dies wurde im Rahmen dieser Diplomarbeit
allerdings nicht realisiert.
Da es sich hierbei um eine App fr Tablet-Computer handelt, steht
dementsprechend viel Platz zum Anzeigen von Informationen zur Verfgung.
Dadurch bietet es sich an, eine zweigeteilte Ansicht zu verwenden. Hierbei besteht
die Mglichkeit, beispielsweise auf der linken Seite des Bildschirms, eine Liste mit
Auswahlmglichkeiten und auf der rechten Seite die zugehri gen Details
darzustellen (siehe Abbildung 13).

Abb 13. Tablet mit zweigeteilter Ansicht

18

Auf einem kleinerem Bildschirm (Smartphone) msste zum Anzeigen der gleichen
Informationen wie auf einem Tablet eine weitere Activity verwendet werden. Diese
wrde beispielsweise nur die Details einer zuvor getroffenen Auswahl anzeigen
(siehe Abbildung 14).

Abb 14. Smartphone mit zwei Activitys zum Anzeigen der gleichen Informationen
wie auf einem Tablet
Listing 1 zeigt das Layout einer zweigeteilten Ansicht auf einem Android-Tablet in
XML-Schreibweise.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:baselineAligned="false"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="horizontal" >

<FrameLayout
android:id="@+id/framelayoutFirmen"
android:layout_weight="1"
android:layout_width="0dp"
android:layout_height="match_parent" >
</FrameLayout>

<FrameLayout
android:id="@+id/framelayoutTabAnsichten"
android:layout_weight="2"
android:layout_width="0dp"
android:layout_height="match_parent"
android:background="@drawable/uptonet_grau" >
</FrameLayout>
</LinearLayout>

Listing 1: Layout-Ressource der Start-Activity

19

Durch die beiden Frame-Layouts innerhalb des Linear-Layouts wird die
Benutzeroberflche geteilt. Das Attribut android:layout_weight="1" gibt an, in
welchem Grenverhltnis die Elemente zueinander stehen. In diesem Beispiel
hat das erste Frame-Layout Element eine layout_weight von 1 und das zweite
Element eine layout_weight von 2. Somit ist das zweite Element doppelt so gro
wie das erste (siehe Abbildung 15).

Abb 15. Grafische Ansicht des Layouts aus Listing 1

Die App wre zu diesem Zeitpunkt schon fehlerfrei kompilier- und ausfhrbar,
allerdings htte sie keinerlei Funktion. Die Activity hat nun die Aufgabe die leeren
Frame-Layouts mit Daten zu fllen (siehe Kapitel 4.3).

4.2 Die Action Bar
Android stellt zur bersichtlichen Navigation innerhalb einer App eine Windows
hnliche Navigationsleiste zur Verfgung. Diese ist permanent am oberen
Bildschirmrand sichtbar und kann unterschiedliche Elemente enthalten, mit denen
der Benutzer interagieren kann. So kann sie z.B. ber eine Tab-Navigation, einen
Zurck-Button, eine Suchleiste und verschiedenste Icons verfgen.

Abb 16. Action Bar

20

Wie in Abbildung 16 zu sehen ist, unterteilt sich die Action Bar in unterschiedliche
Bereiche:
- Applikations-Icon, das gleichzeitig als Zurck-Button fungiert
- berschrift der Activity
- Tab-Navigation
- Suchfeld
- Icon zum Anlegen von Kontakten
4.2.1 Implementierung der Action Bar
Jede Activity besitzt bereits eine verwendbare Action Bar. Dazu bentigt man eine
Objektinstanz der Klasse ActionBar, die man sich durch den Funktionsaufruf in
Listing 2 bergeben lassen kann.
ActionBar actionBar = getActionBar();
Listing 2: Erzeugen eines ActionBar Objektes
Nun knnen mit Hilfe des Objektes actionBar der Navigationsleiste weitere
Elemente hinzugefgt werden (siehe Listing 3).
actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS); //Tab-Navigation
actionBar.setTitle(firmenname); //berschrift setzen
actionBar.setDisplayHomeAsUpEnabled(true); //Beim Klick auf das App-Icon zur
vorherigen Activity wechseln
//Tabs erzeugen
ActionBar.Tab tabKontakte = actionBar.newTab().
setText(getResources().getString(R.string.kontakte))
.setIcon(R.drawable.kontakt_label);
ActionBar.Tab tabDokumente = actionBar.newTab().setText(getResources().
getString(R.string.dokument)).setIcon(R.drawable.anhang_label);

//Der ActionBar die Tabs hinzufgen
actionBar.addTab(tabKontakte);
actionBar.addTab(tabDokumente);

Listing 3: Der Action Bar Elemente hinzufgen
In Listing 3 wird der Action Bar eine berschrift, zwei Tabs und ein Zurck-
Button hinzugefgt. An dieser Stelle wre beim Ausfhren der Applikation die
Action Bar bereits sichtbar, allerdings wrde hinter den einzelnen Elementen
keinerlei Funktion stecken. Eine detaillierte Beschreibung zum Reagieren auf
Benutzereingaben findet sich in Kapitel 4.4.

21

4.2.2 Options Men
Seit Android-Version 3 ist es zustzlich mglich, der Action Bar ein Optionsmen
anzuhngen. Dieses war zuvor meist nur ber einen eigens fr diesen Zweck
enthaltenen Men-Button zu erreichen
15
. Jede Activity besitzt die berschreibbare
Methode onCreateOptionsMenu(Menu menu), in der das Optionsmen zu
implementieren ist. Dies ist auf zwei unterschiedliche Arten realisierbar.
Zum einen ist es mglich eine Ressourcendatei (hnlich einem Layout) anzulegen
(siehe Listing 4).
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android" >
<item android:id="@+id/kontaktSpeichern" android:icon="@drawable/ok"
android:title="@string/speichern" android:showAsAction="always|withText">
</item>

<item android:id="@+id/kontaktNichtSpeichern"
android:icon="@drawable/abbrechen" android:title="@string/abbrechen"
android:showAsAction="always|withText">
</item>

<item android:id="@+id/captureImage" android:icon="@drawable/camera"
android:title="@string/dokumentScannen" android:showAsAction="always">
</item>
</menu>

Listing 4: Beispiel einer in XML realisierten Action Bar
Diese ist nun innerhalb der Methode onCreateOptionsMenu(Menu menu) mit Hilfe des
MenuInflaters (frei bersetzt: Menaufblser) einzubinden (siehe Listing 5).
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
this.getMenuInflater().inflate(R.menu.neuenkontaktoptionsmenue, menu);

return super.onCreateOptionsMenu(menu);
}

Listing 5: Die Men Ressource in die Action Bar einbinden
Eine andere Mglichkeit das Options Men ohne Hilfe von Ressourcendateien
direkt in der Methode onCreateOptionsMenu(Menu menu) zu beschreiben, ist in Listing
6 dargestellt.

15
Quelle: http://android-developers.blogspot.de/2012/01/say-goodbye-to-menu-button.html (Stand
08. September 2012)

22

@Override
public boolean onCreateOptionsMenu(Menu menu)
{
MenuItem itemSpeichern = menu.add("Speichern");
MenuItem itemAbbrechen = menu.add("Abbrechen");
MenuItem itemCaptureImage = menu.add("Bild aufnehmen");

itemSpeichern.setIcon(R.drawable.ok);
itemSpeichern.setShowAsAction(MenuItem.SHOW_AS_ACTION_WITH_TEXT);
itemAbbrechen.setIcon(R.drawable.abbrechen);
itemAbbrechen.setShowAsAction(MenuItem.SHOW_AS_ACTION_WITH_TEXT);
itemCaptureImage.setIcon(R.drawable.camera);
itemCaptureImage.setShowAsAction(MenuItem.SHOW_AS_ACTION_WITH_TEXT);

return super.onCreateOptionsMenu(menu);
}

Listing 6: Options Men ohne Ressourcendatei erstellen
Die grafische Darstellung der Option-Buttons auf der Action Bar ist in Abbildung 17
dargestellt.

Abb 17. Grafische Darstellung der Option-Buttons



23

4.3 Die Activity mit Daten fllen
Wie in Kapitel 4.1 beschrieben, besteht die Activity aus mehreren Frame-Layouts.
Um diese nun mit Hilfe von Fragmenten zu fllen, bentigt man zunchst eine
Klasse, die von Fragment bzw. ListFragment erbt.
4.3.1 Die Klasse ListFragment
Als Beispiel wird die Klasse ListFragmentAnsprechpartner.java nher betrachtet.
Sie hat die Aufgabe alle Ansprechpartner einer Firma aus der gerteinternen
Telefonbuch-Datenbank zu laden und diese mit Name und Bild anzuzeigen (siehe
Abbildung 18).

Abb 18. ListFragment mit individuellem Layout

Diese Klasse erbt von der aus dem Android-Framework stammenden Klasse
ListFragment und ist dadurch in der Lage Inhalte in Form einer Liste darzustellen.
Zudem implementiert sie bereits Methoden, mit deren Hilfe auf Benutzereingaben
reagiert werden kann.
Die Klasse ListFragmentAnsprechpartner.java ldt eigenstndig Daten aus einer
Datenbank und zeigt diese in Listenform an. Wird nun ein Eintrag durch den
Benutzer selektiert, informiert dieses Fragment mit Hilfe eines Listeners die
Activity, dass ein Eintrag ausgewhlt wurde (eine Erluterung des Begriffs Listener
findet sich in Kapitel 4.4.1). Diese kann nun auf die Eingabe reagieren. Somit
besitzt das Fragment einzig die Aufgabe Daten zu laden, diese anzuzeigen und
eine andere Klasse ber Benutzereingaben zu informieren. Ein solches Konzept
hat den groen Vorteil, dass dadurch das Fragment abgekapselt wird und an

24

anderen Stellen im Programm wiederverwendet werden kann.
4.3.2 Implementierung der Klasse ListFragmentAnsprechpartner
Zunchst wird ein Objekt der Klasse ListFragmentAnsprechpartner erzeugt.
private ListFragmentAnsprechpartner listFragmentAnsprechpartner =
new ListFragmentAnsprechpartner(this, firma_uId);

Listing 7: Anlegen eines Objektes der Klasse ListFragmentAnsprechpartner
Als bergabeparameter werden der Context der Activity und die Unique-Id der
Firma bergeben. Der Context ist ein Interface, mit dem man Zugriff auf
androidspezifische Ressourcen und Klassen hat. Beispielsweise kann man mit
dem Context auf Datenbanken oder String-Ressourcen zugreifen. Eine
Erluterung zu dem Begriff Unique-Id findet sich im Anhang A.
An dieser Stelle ist es wichtig zu erwhnen, dass mit dem Erstellen des Objektes
aus Listing 5 das Fragment noch nicht in der Activity gezeichnet wird. Es wird
lediglich der Konstruktor aufgerufen und Speicherplatz fr dieses Objekt reserviert.
Android entscheidet eigenstndig darber, wann ein Fragment gezeichnet wird,
bzw. wann die Methode onCreateView() der Fragment-Klasse aufgerufen wird.
Android bietet die Mglichkeit, unterschiedliche Methoden, wie z.B.
onCreateView(), onActivityCreated(), onPause(), onResume(), etc. zu
berschreiben. Dadurch ist man in der Lage, in unterschiedliche Lebenszyklen
eines Fragments oder einer Activity einzugreifen. Beispielsweise wird die Methode
onPause() immer dann aufgerufen, wenn eine Activity in den Hintergrund gelangt,
bzw. nicht mehr sichtbar ist, weil sie geschlossen oder eine andere Activity
geffnet wurde. Somit ist dies die richtige Stelle, an der man Daten speichern
sollte, um die Activity wiederherstellen zu knnen, nachdem diese gegebenenfalls
aus dem Speicher bereinigt wurde. Die Wiederherstellung der Daten sollte in der
Methode onResume() erfolgen. Diese wird immer dann aufgerufen, wenn die
Activity wieder sichtbar wird. Nheres ber den Lebenszyklus einer Activity findet
sich im Anhang A.
In Listing 6 wird das berschreiben der Methode onCreateView() dargestellt.
Diese Methode wird aufgerufen, wenn Android bereit ist das ListFragment-Objekt
zu erzeugen.


25

private List<AnsprechpartnerInformationen> kundeninfoListe;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState)
{
//Kontakte laden
kundeninfoListe = ladeAnsprechpartnerAusTelefonbuch(firma_uId);

//Eigenen Adapter erzeugen, um Firmenmitarbeiter mit Bild und Name
anzuzeigen
AdapterAnzeigeBildUndName adapter =
new AdapterAnzeigeBildUndName(context, kundeninfoListe);

//FragmentListe Adapter setzen
this.setListAdapter(adapter);

return super.onCreateView(inflater, container, savedInstanceState);
}

Listing 8: Die Methode onCreateView() berschreiben
Mit der Methode ladeAnsprechpartnerAusTelefonbuch(firma_uId) werden alle
Ansprechpartner, die zu einer bestimmten Firma gehren aus der Android eigenen
Telefonbuch-Datenbank ausgelesen und in die ArrayList kundeninfoListe
geschrieben (eine nhere Beschreibung zum Auslesen von Daten aus einer
Datenbank findet sich in Kapitel 6). Diese ArrayList kann Objekte vom Typ
AnsprechpartnerInformationen aufnehmen. Es handelt sich hierbei um eine Klasse,
deren einzige Aufgabe darin besteht, gewisse Kundeninformationen (Name, E-
Mail, Adresse, Webseite etc.) aufzunehmen und diese mit Hilfe von Getter- und
Setter Methoden verfgbar zu machen.
Zum Anzeigen der geladenen Daten wird ein so genannter Adapter bentigt. Ein
Adapter ist eine Klasse, die von der Android-Klasse BaseAdapter erbt und
verschiedene Methoden implementiert, mit deren Hilfe Daten auf dem Bildschirm
angezeigt werden knnen. Das Konzept hinter Adaptern ist, dass sie
unterschiedlichste Daten verwalten und anzeigen knnen, dabei aber immer die
gleiche Schnittstelle verwenden. Android stellt bereits verschiedene Adapter zur
Verfgung (ArrayAdapter, CursorAdapter etc.).
Dabei wird das Architekturmuster des Model View Controllers verfolgt, mit dem es
mglich ist eine hohe Wiederverwendbarkeit der einzelnen Komponenten zu
erreichen
16
(siehe Abbildung 19).

16
Nhere Informationen zu dem Konzept des Model View Controllers findet sich unter:
http://de.wikipedia.org/wiki/Model_View_Controller (Stand 15.September 2012)

26


Abb 19. Konzept des Model-View-Controllers

Um individuelle Daten, wie in diesem Fall ein Bild mit zugehrigem Namen
anzuzeigen, muss ein eigener Adapter implementiert werden (siehe Listing 9).
Vorteil eines eigens erstellten Adapters ist, dass man vllig freie Hand hat, in
welcher Art und Weise man die Daten darstellen mchte. Hierzu wird eine Layout-
Ressource angefertigt (gleiche Vorgehensweise wie bei einer Activity), die das
Aussehen jeder einzelnen Zeile der Liste bestimmt.

27

public class AdapterAnzeigeBildUndName extends BaseAdapter
{
private Context context;
private List<AnsprechpartnerInformationen> kundeninfoListe;

public AdapterAnzeigeBildUndName(Context context,
List<AnsprechpartnerInformationen> kundeninfoListe)
{ //Konstruktor
this.context = context;
this.kundeninfoListe = kundeninfoListe; //An den Adapter bergebene
//Daten, die angezeigt werden sollen
}

public int getCount()//Gibt die Anzahl der Listenelemente zurck
{
if(kundeninfoListe != null) return kundeninfoListe.size();
return 0;
}

public Object getItem(int position)//Gibt ein Element in der Liste zurck
{
if(kundeninfoListe != null) return kundeninfoListe.get(position);
return null;
}

public long getItemId(int position)//Gibt die Item-Position innerhalb der
//Liste zurck
{
return position;
}

public View getView(int position, View convertView, ViewGroup parent)
{
View result = convertView; //Bereits vorhandene Elemente werden
//recycelt
if(result == null)
{
//Elemente knnen nicht recycelt werden und mssen aus diesem
//Grund neu gezeichnet werden
//LayoutInflater Objekt erzeugen
LayoutInflater inflater = (LayoutInflater) context.
getSystemService(Context.LAYOUT_INFLATER_SERVICE);
//Layout aufpumpen
result = inflater.inflate(R.layout.layout_anzeige_bildundname,
null);
}
TextView tvAnzeigename = (TextView)result
.findViewById(R.id.TextViewAnzeigenameVorschau);
ImageView imageViewIcon = (ImageView)result.
findViewById(R.id.imageViewFotoThumbnail);
if(kundeninfoListe != null)
{ //Name und Foto setzen
tvAnzeigename.setText(kundeninfoListe
.get(position).getAnzeigename());
imageViewIcon.setImageBitmap(kundeninfoListe.
get(position).getFoto());
}
return result;
}
}

Listing 9: Adapter zum Anzeigen von individuellen Daten


28

Die fertige Adapter-Klasse muss nun instanziiert werden (siehe Listing 10).
AdapterAnzeigeBildUndName adapter =
new AdapterAnzeigeBildUndName(context, kundeninfoListe);

Listing 10: Ein Objekt vom Typ AdapterAnzeigeBildUndName erzeugen
Damit das ListFragment wei, welcher Adapter zum Anzeigen der Daten
verwendet werden soll, muss mit this.setListAdapter(adapter); der zuvor
erzeugte Adapter gesetzt werden.

4.4 Reagieren auf Benutzereingaben
4.4.1 Das Prinzip der Listener
Hinter dem Prinzip der Listener verbirgt sich ein sehr mchtiger Mechanismus,
nmlich der des Interfaces. Ein Interface enthlt, hnlich einer normalen Java-
Klasse, eine oder mehrere Methoden, die zwar deklariert werden, aber noch
keinerlei Funktion besitzen (siehe Listing 11). Es wird lediglich festgelegt, dass es
diese Methode(n) gibt, die Implementierung selbst muss aber von einer anderen
Klasse bernommen werden.
public interface ListenerOnAnsprechpartnerSelected
{
public abstract void onAnsprechpartnerClicked(String ansprechpartner_uId);
}

Listing 11: Beispiel eines J ava Interface mit einer Methode
Mit Hilfe dieses Mechanismus ist es mglich eine Klasse bei einer anderen Klasse
als Listener zu registrieren um beim Auftreten von bestimmten Ereignissen
(beispielsweise wenn ein Button gedrckt wurde) benachrichtigt zu werden.
4.4.2 Listener registrieren
Viele Android-Klassen nutzen dieses Prinzip, indem sie eine public Methode zur
Verfgung stellen, die es erlaubt, sich als so genannter Listener zu registrieren.
Als Beispiel werden die Tabs in der Action Bar betrachtet. Mit
tabKontakte.setTabListener(this); registriert man sich bei dem Objekt tabKontakte
der Klasse Tab als Listener. Mit this als bergabeparameter wird festgelegt, dass
man selbst (die Klasse in der der Listener registriert wird) das Interface

29

implementieren mchte. Im Falle des Tab-Listeners besitzt das Interface drei
Methoden, die nun auszuformulieren sind (siehe Listing 12).
public void onTabReselected(Tab tab, FragmentTransaction ft)
{
//Wird aufgerufen, nachdem ein Tab erneut ausgewhlt wurde
}

public void onTabSelected(Tab tab, FragmentTransaction fmt)
{
//Wird aufgerufen, nachdem ein Tab selektiert wurde
}

public void onTabUnselected(Tab tab, FragmentTransaction ft)
{
//Wird aufgerufen, nachdem ein Tab deselektiert wurde
}

Listing 12: Methoden des Interface TabListener
Wenn der Benutzer nun einen Tab auswhlt, reagiert die Klasse Tab auf dieses
Ereignis und ruft die passende Methode des Interface auf. Nun wird bei allen
Klassen die als Listener registriert sind diese Methode aufgerufen, in der nun auf
die Tab-Selektion reagiert werden kann.
Weitere Klassen, bei denen es mglich ist sich als Listener zu registrieren, sind
beispielsweise die Android-Klassen Button und SearchView. Die Vorgehensweise ist
im Grunde immer gleich. Man registriert eine Klasse als Listener, implementiert
dessen Interface, bernimmt alle zu implementierenden Methoden in seine Klasse
und formuliert diese aus.
Bei manchen Klassen ist es nicht notwendig sich als Listener zu registrieren.
Wenn man z.B. eine Klasse von ListFragment ableitet, ist die Vorgehensweise ein
wenig anders. Diese Klasse besitzt bereits eine Methode public void
onListItemClick(), die berschrieben werden kann. Man muss sich also in
diesem Fall nicht als Listener registrieren und ein Interface implementieren,
sondern kann direkt in dieser Methode auf eine Benutzereingabe reagieren.
Es besteht natrlich auch die Mglichkeit ein eigenes Interface zu erstellen und zu
implementieren. Dies wurde in diesem Projekt in allen ListFragment-Klassen
eingesetzt, um mit Hilfe eines Listeners die Activity zu benachrichtigen, dass ein
Eintrag durch den Benutzer ausgewhlt wurde. Diese Vorgehensweise ist ntig,
damit nur die Activity die Steuerung der einzelnen Fragmente bernimmt und

30

diese sich nicht gegenseitig steuern. Dies stellt die Wiederverwendbarkeit der
Fragmente sicher (siehe Abbildung 20).

Abb 20. Steuerung der einzelnen Elemente durch die Activity

4.4.3 Reagieren auf Benutzereingaben der Action Bar
In manchen Fllen ist es nicht ntig einem Element einen Listener zu setzen, da
die bentigten Funktionen bereits durch das Android-Framework implementiert
sind. Dies ist z.B. bei Men- und Option-Items auf der Action Bar der Fall. Um auf
Benutzereingaben dieser Elemente zu reagieren, besitzt die Activity bereits zwei
berschreibbare Methoden, public boolean onOptionsItemSelected(MenuItem item)
und public boolean onMenuItemSelected(int featureId, MenuItem item). Diese
werden, je nachdem ob es sich um ein Men- oder um ein Option-Item handelt,
nach einer Benutzereingabe aufgerufen. Um z.B. auf einen Klick auf das Icon der
Applikation zu reagieren, muss auf dessen Item-Id abgefragt werden (siehe Listing
13). Die Vorgehensweise fr Option-Items ist analog und wird deshalb nicht nher
betrachtet.

31

@Override
public boolean onMenuItemSelected(int featureId, MenuItem item)
{
//Wurde das Icon der Applikation in der Action Bar gedrckt, wird die
Activity beendet
if(item.getItemId() == android.R.id.home) finish();

//Die Activity beim Schlieen animieren
overridePendingTransition(R.animator.activity_enter_animation_right_to_left,
R.animator.activity_exit_animation_right_to_left);

return super.onMenuItemSelected(featureId, item);
}

Listing 13: Reagieren auf eine Menauswahl


32

5 Synchronisation der Daten
Ein wichtiger Bestandteil dieser Diplomarbeit ist die Synchronisation von Daten
zwischen dem UpToNet

und mobilen Endgerten. Diese luft ber einen Cloud-


hnlichen Dienst ab, bei dem die zu synchronisierenden Daten an einer zentralen
Stelle gesammelt werden und von dort aus abrufbar sind.

Abb 21. UpToNet

Cloud Modell
Datenstze, die aus dem UpToNet

synchronisiert werden sollen, mssen zuvor


explizit ausgewhlt und exportiert werden. Dies hat den Vorteil, dass nur wichtige
Informationen auf dem Endgert vorhanden sind und zudem kein unntiger
Datentransfer in der Cloud entsteht.
Das Synchronisieren von Daten, die sich auf den mobilen Gerten befinden, muss
ebenfalls manuell gestartet werden. Dadurch kann der Zeitpunkt des
Synchronisierens durch den Benutzer festgelegt werden. Dieser hat somit die
Mglichkeit den Synchronisationsvorgang nur dann zu starten, wenn eine schnelle
und geeignete Internetverbindung zur Verfgung steht.
5.1 Synchronisation mit Hilfe von Online-Konten
Unter Android ist es mglich, in manchen Fllen sogar zwingend erforderlich, ein
Online-Konto anzulegen und zu verwalten. Beispielsweise wird zum Herunterladen
von Apps aus dem Android Market ein Google-Konto bentigt. Mit Hilfe dieser
Konten knnen zudem beliebige Daten synchronisiert werden. Um dieses Prinzip
nutzen zu knnen, muss ein eigenes Konto erstellt werden, ber das die gesamte

33

Synchronisation abgearbeitet wird. Alle Online-Konten werden in den
Einstellungen des Android-Betriebssystems verwaltet (siehe Abbildung 22).

Abb 22. Kontenverwaltung
Von hier aus ist es nun mglich, die Synchronisation zu starten (siehe Abbildung
23).

Abb 23. Starten der Synchronisation
Jedes Konto bentigt zur Anmeldung am entsprechenden Onlineserver eine

34

Authentifizierung mittels Benutzername und Passwort.
Fr die Durchfhrung der Synchronisation muss eine neue Klasse erstellt werden,
die von AbstractThreadedSyncAdapter erbt und die Methode public void
onPerformSync() berschreibt und implementiert. In dieser Methode knnen nun
alle bentigten Daten mit dem Cloud-Server ausgetauscht werden. Durch die
Synchronisation mit Hilfe eines Kontos wird der Synchronisationsvorgang in einem
eigenen Thread gestartet. Dadurch knnen Netzwerk- und Datenbankzugriffe
ausgefhrt werden, ohne das Betriebssystem zu blockieren. Der Ablauf der
Synchronisierung in der Methode public void onPerformSync() wird im folgenden
Kapitel erlutert.

5.2 Ablauf der Synchronisation
In Abbildung 24 ist der Ablaufplan der Synchronisation dargestellt. An dieser Stelle
ist zu erwhnen, dass Daten, die whrend der Benutzung der App gelscht
werden, noch nicht endgltig aus der Datenbank entfernt werden. Es wird lediglich
ein Delete-Flag gesetzt. Das endgltige Entfernen der Daten aus der Datenbank
erfolgt erst whrend des Synchronisationsvorganges. Dies dient der Vorbereitung
zur Synchronisation von gelschten Daten und soll evtl. in einer spteren Version
der App realisiert werden.

35


Abb 24. Ablaufplan der Synchronisation

36

Der Punkt Daten aus der Cloud synchronisieren kann als eigener Prozess
angesehen werden und wird in einem gesonderten Ablaufplan dargestellt (siehe
Abbildung 25).


37


Abb 25. Ablaufplan zum Synchronisieren von Daten aus der Cloud
5.3 Synchronisieren von Dokumenten
Alle Serveranfragen werden mittels HttpGet ausgefhrt (siehe Listing 14). Der
Server antwortet mit einem HttpResponse, aus dem der entsprechende InputStream
ausgelesen wird. Je nachdem, ob eine Anfrage auf einen Ordner oder eine Datei

38

an den Server gesendet wurde, enthlt der InputStream entweder einen XML-
Datenstrom (siehe Listing 15) oder die angeforderte Datei.
//HTTP-Get Anfrage stellen
HttpGet httpget = new HttpGet(prismaDownloadUrl + "/" + encodedPath);
HttpClient httpclient = new DefaultHttpClient();
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
InputStream instream = entity.getContent();

Listing 14: Anfrage an den Server schicken
Zu Beginn der Synchronisation ist die erste Anfrage an den Cloud-Server immer
eine Abfrage auf den Kundenordner des Benutzers. Dadurch wird erreicht, dass
der Server mit einem XML-Datenstrom antwortet, der im Anschluss analysiert
wird.
Diese Verfahrensweise hat den groen Vorteil, dass nur wenige Kilobyte an
Datentransfer ntig sind, um zu berprfen, ob alle Daten auf dem Endgert
vorhanden und aktuell sind.
<uptonet-cloud>
<file type="file" modified="1343907964000" size="2636295"
hash="bfd841913363635a8f538d23cd6d72561a6abafe63abf49ad58789b8bfc729d">
Adressen und Kontakte 2012-08-02-13-32.uxp
</file>

<file type="dir" modified="1345536301000">
Anhnge
</file>
</uptonet-cloud>

Listing 15: XML-Datenstrom
Der XML-Datenstrom enthlt Informationen ber den Dateityp (Ordner oder Datei),
nderungsdatum (in Millisekunden), Dateigre (in Kilobyte) und Dateiname.
Dabei beinhaltet ein File-Tag (<file></file>) auerdem alle Metadaten zu einer
Datei. Bei der serverseitigen Erstellung des nderungsdatums in Millisekunden
werden die letzten drei Ziffern durch 0 ersetzt. Der Grund dafr ist, dass das
Android-System Dateinderungen nur sekundengenau abspeichert und ohne
diese Korrektur der Zeit keine brauchbare Abfrage auf das nderungsdatum
erfolgen knnte.
Alle Metadaten einer Datei werden als Objekte einer Klasse gespeichert. Diese

39

Klasse hat ausschlielich die Aufgabe, Informationen mittels Settermethoden
aufzunehmen und mittels Gettermethoden verfgbar zu machen. Alle
Klassenobjekte werden daraufhin in einer ArrayListe abgelegt und
zwischengespeichert. Im Anschluss wird die Liste mithilfe einer for-Schleife
durchlaufen, wobei jedes Objekt nach einer bestimmten Vorgehensweise
untersucht wird.
Handelt es sich bei dem Dateityp um eine tatschliche Datei (type="file"), wird
zunchst berprft, ob die Datei bereits auf dem Dateisystem existiert. Ist dies der
Fall, wird mithilfe der Metadaten (Gre, nderungsdatum und Hashwert) geprft,
ob die Datei gendert wurde. Ist die Datei noch nicht vorhanden oder eine neuere
Version auf dem Server verfgbar, wird diese vom Server angefordert und
heruntergeladen. Angeforderte Dateien knnen entweder Anhnge von Kontakten
oder aber Datenbankexporte sein. Letztere werden in eine spezielle Datei
geschrieben (nheres zu diesen Dateien findet sich in Kapitel 5.4).
Ist die Datei vom Typ Dateiordner (type="dir"), wird erneut ein XML-Datenstrom
vom Server angefordert, der alle Dateien dieses Unterordners auflistet. Dadurch
kommt es zur Rekursion innerhalb der Funktion. Die ArrayListe ist noch nicht
vollstndig durchlaufen, fordert aber bereits einen neuen XML-Datenstrom vom
Server an, der daraufhin zuerst abgearbeitet wird. Diese Rekursion wiederholt
sich, entsprechend der Anzahl der Unterordner. Die Ordnerstruktur auf dem
Server wird dabei exakt auf dem Endgert nachgebildet.

5.4 Synchronisieren von Datenbankeintrgen
Das Synchronisieren von Datenstzen aus einer Datenbank erfolgt mit Hilfe von
speziellen Dateien (im Weiteren Journale genannt). Diese beinhalten die
einzelnen Datenexporte in tabellarischer Form (siehe Listing 17). Die jeweiligen
Zeilen einer Datenbanktabelle sind innerhalb des Journals durch eine Leerzeile
getrennt. Somit ergeben sich einzelne Blcke, von denen jeweils einer einem
Datensatz in der Datenbank entspricht.
Jeder dieser Blcke besitzt an erster Stelle eine Kopfzeile, die Informationen
darber enthlt, um welche Art von Datensatz es sich handelt. Diese lsst sich in
vier Elemente zerlegen, von denen jedes durch einen Doppelpunkt getrennt ist.

40

Die Kopfzeile x:Kontaktart:2:{6ec057eb-2583-4f9f-b1e4-9a4dceffc35b} besteht aus:
x: Art des Datenbankexports [u = update, i = insert, d = delete, x = export]
Kontaktart: Name der Datenbanktabelle
2: Interne Datensatz-Id im UpToNet
{6ec057eb-2583-4f9f-b1e4-9a4dceffc35b}: Unique-Id des Datensatzes
Listing 16: Bedeutung der einzelnen Elemente der Kopfzeile
Im Anschluss an die Kopfzeile folgen die eigentlichen Daten der Tabelle. Diese
bestehen aus drei Elementen, die ebenfalls durch einen Doppelpunkt getrennt
sind. Das erste Element gibt den Spaltennamen der Datenbanktabelle an. Die
zweite Stelle ist eine Integer-Zahl, die angibt aus wie vielen Bytes sich die
eigentliche Information (drittes Element) zusammensetzt. Dadurch ist es mglich,
dass ein einzelnes Feld eines Datensatzes mehrere Zeilen in einem Journal
belegt.
x:Kontaktart:2:{6ec057eb-2583-4f9f-b1e4-9a4dceffc35b}
KONART_AENDERUNGAM:16:11.06.2012 15:51
KONART_AENDERUNGDURCH:38:{8fb7e4ad-2444-4149-96eb-54c8aa83f047}
KONART_Bezeichnung:7:Telefon
KONART_Id:1:2
KONART_Intern:1:3
KONART_Symbol:0:
PUID:38:{6ec057eb-2583-4f9f-b1e4-9a4dceffc35b}

x:Kontakt:714:{455f2c13-ac7c-435a-acb8-54034a8d189d}
KON_Adresse:38:{e6182fb3-b6c4-47b6-ab5d-84fcf25f5f50}
KON_AENDERUNGAM:16:12.06.2012 14:01
KON_AENDERUNGDURCH:38:{8fb7e4ad-2444-4149-96eb-54c8aa83f047}
KON_ANLAGEAM:16:12.06.2012 13:47
KON_Anlagedatum:16:12.06.2012 13:47
KON_ANLAGEDURCH:38:{8fb7e4ad-2444-4149-96eb-54c8aa83f047}
KON_Ansprechpartner:38:{87e76247-3bb4-4aae-ad47-951c6518af29}
KON_Beginn:16:12.06.2012 13:46
KON_Betreff:9:Telefonat
KON_Datum:16:12.06.2012 13:46
KON_Dauer:4:0,02
KON_Ende:16:12.06.2012 13:47
KON_Id:3:714
KON_Kontaktart:38:{6ec057eb-2583-4f9f-b1e4-9a4dceffc35b}
KON_Mitarbeiter:38:{8fb7e4ad-2444-4149-96eb-54c8aa83f047}
PUID:38:{455f2c13-ac7c-435a-acb8-54034a8d189d}

Listing 17: Beispiel einer J ournal-Datei
Die Vorgehensweise zum Analysieren der Journale und anschlieendem
Eintragen der ausgelesenen Datenstze in die Datenbank ist in Abbildung 26
dargestellt.

41


Abb 26. Analyseablaufplan der J ournal-Datei

42

6 Datenspeicherung in Datenbanken
Android stellt zur Speicherung von Daten eine in das Android SDK integrierte
SQLite-Bibliothek zur Verfgung. Hierbei handelt es sich um eine abgespeckte
Version eines SQL-Datenbankmanagementsystems. Dieses ist vor allem fr den
Embedded-Einsatz entworfen worden und besitzt zu diesem Zweck eine nur
wenige Kilobyte groe Bibliothek
17
. SQLite besitzt gegenber anderen
Datenbankmanagementsystemen einige Nachteile
18
. Diese sind:
- Nicht alle JOIN-Befehle werden untersttzt. LEFT OUTER JOIN ist implementiert,
RIGHT OUTER JOIN und FULL OUTER JOIN werden nicht untersttzt.
- Der Befehl ALTER TABLE ist nur teilweise realisiert. RENAME TABLE und ADD
COLUMN werden untersttzt, alles andere ist nicht implementiert.
- TRIGGER vom Typ FOR EACH ROW werden untersttzt, FOR EACH
STATEMENT TRIGGER nicht.
- VIEWS knnen erstellt, aber nur gelesen werden. Die Befehle DELETE, UPDATE
und INSERT knnen nicht auf eine VIEW angewendet werden.
- Es ist nicht mglich Berechtigungen fr verschiedene Benutzer anzulegen.
SQLite kommt nicht nur auf Android-Gerten zum Einsatz, sondern wird ebenfalls
von namhaften Herstellern wie Apple, Mozilla, Adobe oder Skype Technologies
verwendet.
Im Rahmen dieser Diplomarbeit wurden zwei unterschiedliche Datenbanken
verwendet. Alle Ansprechpartner und Firmen mit Adresse, Telefonnummer etc.
werden in die bereits auf dem Endgert befindliche Telefonbuchdatenbank
geschrieben. Der Vorteil an dieser Lsung ist, dass kein eigenes Konzept zum
Verwalten und Anzeigen dieser Daten entwickelt werden musste, sondern das
Android-Telefonbuch verwendet werden konnte. Dieses stellt innerhalb der
Telefonbuchdatenbank insgesamt vier SYNC-Felder zur Verfgung, die mit
eigenen Daten zur Synchronisation beschrieben werden knnen. Hier wurde in
das SYNC1-Feld die Unique-ID des Ansprechpartners eingetragen. Dies dient
der eindeutigen Unterscheidung der jeweiligen Ansprechpartner. Das SYNC2-
Feld wird mit einem Flag belegt, welches den jeweiligen Ansprechpartner als
Person oder Firma kennzeichnet (0 = Person, 1 = Firma).

17
Quelle: http://de.wikipedia.org/wiki/SQLite (Stand 17. September 2012)
18
Quelle: http://www.sqlite.org/omitted.html (Stand 17. September 2012)

43

Zum Speichern und Verwalten der restlichen Daten, wie z.B. Kontakten,
Mitarbeiter etc. wurde eine eigene Datenbank entwickelt. In Abbildung 27 ist die
Datenstruktur der Datenbank des mobilen Bros im Zusammenspiel mit der
Android-Telefonbuchdatenbank dargestellt. Innerhalb dieser werden
Ansprechpartner in der Tabelle RawContact angelegt. Jeder Eintrag innerhalb
dieser Tabelle wird einem bestimmten Synchronisationskonto zugeordnet.
Dadurch ist es mglich, dass eine Person mehrfach in der Tabelle RawContact
erscheint, je nachdem durch welche Quelle sie angelegt bzw. synchronisiert wurde
(Bsp. Google, Facebook, E-Mail Account, usw.). Alle Kontaktinformationen wie
Adresse, Telefonnummer etc. werden in der Tabelle Data abgelegt, welche auf
die Tabelle RawContact verweist.

Abb 27. Datenbankmodell der UpToNet

Mobile Datenbank
Fr das Erstellen einer Datenbank wird eine Klasse bentigt, die von
SQLiteOpenHelper erbt und die Methoden public void onCreate(SQLiteDatabase db)
und public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
berschreibt. Innerhalb dieser Methoden ist die Neuerstellung und Aktualisierung
einer Datenbank zu implementieren. Ein Beispiel zur Erstellung einer neuen
Datenbank ist in Listing 18 dargestellt.

44

@Override
public void onCreate(SQLiteDatabase db)
{
db.execSQL(Kontakte.CREATE_TABLE);
db.execSQL(Kontaktart.CREATE_TABLE);
db.execSQL(Mitarbeiter.CREATE_TABLE);
db.execSQL(Anhang.CREATE_TABLE);
createKontaktarten(db); //Kontaktarten Datenbank initial befllen
}

Listing 18: Neue Datenbank erstellen
Zur besseren bersicht und zur leichteren Pflege der Datenbank werden alle
enthaltenen Tabellen durch eine eigene Klasse reprsentiert (ein Beispiel ist in
Listing 19 anhand der Klasse Kontaktart dargestellt). Diese Klasse enthlt
Konstanten fr die jeweiligen Spalten, den Namen, den MIME-Type und einen
String zum Erstellen der Datenbanktabelle.
Dieses Konzept hat den Vorteil, dass nderungen jeweils nur an einer zentralen
Stelle ausgefhrt werden und sich von dort aus auf das gesamte Projekt
auswirken. Zudem bietet es eine bersichtliche Ansicht aller Elemente einer
Tabelle.
public class Kontaktart
{
public static class Columns implements BaseColumns
{
public static final String KONART_BEZEICHNUNG = "KONART_Bezeichnung";
public static final String KONART_ICON_ID = "KONART_ICON_Id";
public static final String KONART_UID = "KONART_UID";
}

public static final String CONTENT_DIRECTORY = "kontaktart";
public static final String TABLE_NAME = "KONTAKTART";
public static final Uri CONTENT_URI = Uri.parse(
"content://"+UpToNetContentProvider.AUTHORITY+"/"+CONTENT_DIRECTORY);
public static final String CONTENT_ITEM_TYPE =
"vnd.android.cursor.item/com.prisma.uptonet.Kontaktart";
public static final String CONTENT_TYPE =
"vnd.android.cursor.dir/com.prisma.uptonet.Kontaktart";

public static final String CREATE_TABLE = "create table "+TABLE_NAME+"( " +
Columns._ID + " integer primary key autoincrement, " +
Columns.KONART_BEZEICHNUNG + " text, " +
Columns.KONART_ICON_ID + " integer, " +
Columns.KONART_UID + " text" +
")";
}

Listing 19: Hilfsklasse zum Reprsentieren einer Datenbanktabelle


45

6.1 Content-Provider
Mit Hilfe eines Content-Providers (frei bersetzt: Inhaltslieferant) bietet man
anderen Anwendungen die Mglichkeit, auf den Inhalt einer
applikationsspezifischen Datenbank zuzugreifen. Beispielsweise hat man ber
einen Content-Provider auf alle Daten innerhalb der gerteinternen
Telefonbuchdatenbank Zugriff. Ein solcher Provider wurde im Rahmen dieser
Diplomarbeit entwickelt. Die Idee dahinter war, allen zuknftig entwickelten Apps
der Firma Prisma GmbH zu ermglichen, auf Daten der UpToNet

Mobile
Datenbank zuzugreifen. Zudem wird dadurch eine definierte Schnittstelle innerhalb
der Applikation implementiert, durch die es theoretisch sogar mglich wre, auf ein
anderes Datenbankmanagementsystem als SQLite umzusteigen, ohne jeden
Datenbankzugriff innerhalb der Applikation ndern zu mssen.
Unter Android besitzt jede Datenquelle eine eindeutige Adresse, welche als URI
(Uniform Resource Identifier) bezeichnet wird. Der Aufbau eines URI folgt dem
Muster: content://<Authority>/<Tablename>/<ID>, wobei die <Authority> den
Besitzer der Daten kennzeichnet, in diesem Fall die Applikation. Diese Authority
besitzt z.B. die Form com.prisma.uptonet und benennt den Content-Provider
innerhalb des Systems. Das Element <Tablename> adressiert eine Tabelle
innerhalb der Datenbank, die durch den Content-Provider verwaltet wird. Mit <Id>
wird eine konkrete Zeile innerhalb der Tabelle adressiert.
Der Zugriff auf den Content-Provider erfolgt ber den Content-Resolver. Dieser
stellt Methoden zum Abfragen (Select), Erstellen (Insert), Aktualisieren (Update)
und Lschen (Delete) von Daten zur Verfgung. Der Resolver lst die Adresse auf
und whlt den zur <Authority> passenden Content-Provider aus. Dieser wird im
Anschluss gestartet und die entsprechende Methode ausgefhrt
19
. Wird
beispielsweise eine Datenbankabfrage (Query) durchgefhrt, liefert der Content-
Provider einen Cursor (einen Zeiger auf Datenbankeintrge) zurck, aus dem die
entsprechenden Ergebniszeilen ausgelesen werden knnen (ein Beispiel ist in
Kapitel 6.2 beschrieben).
Fr die Erstellung eines Content-Providers wird eine neue Klasse bentigt, die von

19
vgl: Bach, Mike(2012): Mobile Anwendungen mit Android - Entwicklung und Praktischer
Einsatz, Mnchen 2012, S.313


46

der Android-Klasse ContentProvider erbt. In dieser neu erstellten Klasse werden
insgesamt fnf Methoden berschrieben, um dem Content-Provider seine
Funktionalitt zu geben. Diese sind:
@Override
public String getType(Uri uri)
{
return null;
}

@Override
public Uri insert(Uri uri, ContentValues values)
{
return null;
}

@Override
public int update(Uri uri, ContentValues values, String selection, String[]
selectionArgs)
{
return 0;
}

@Override
public int delete(Uri uri, String selection, String[] selectionArgs)
{
return 0;
}

@Override
public Cursor query(Uri uri, String[] projection, String selection, String[]
selectionArgs, String sortOrder)
{
return null;
}

Listing 20: Wichtigste Methoden innerhalb des Content Providers
Die weitere Implementierung des Content-Providers ist sehr umfangreich und wird
aus diesem Grund nicht nher beschrieben. Die vollstndige Klasse
UpToNetContentProvider findet sich auf der CD im Anhang B dieser Diplomarbeit.

6.2 Zugriff auf Datenbankinhalte
Wie in Kapitel 6.1 erwhnt, erfolgt der Zugriff auf Content-Provider und somit auf
Datenbankinhalte ber die Klasse ContentResolver. Ein Objekt dieser Klasse erhlt
man ber den Methodenaufruf getContentResolver(). Mit diesem ist es nun
mglich auf die Datenbank zuzugreifen. Ein Beispiel fr eine Datenbankabfrage
mithilfe des ContentResolver ist in Listing 21 dargestellt.

47

Cursor cursor = getContentResolver().query(
Kontaktart.CONTENT_URI, //URI der abzufragenden Tabelle
new String[]
{Kontaktart.Columns.KONART_UID}, //Tabellenspalte die zurck gegeben wird
Kontaktart.Columns.KONART_BEZEICHNUNG + " =?", //Abfragebedingung (where...)
new String[]{"Brief"}, //Ersetzt das ? in der Abfragebedingung
Kontaktart.Columns.KONART_UID); //Sortierungsreihenfolge

while (cursor.moveToNext())
{
String unique_id = cursor.getString(
cursor.getColumnIndex(Kontaktart.Columns.KONART_UID))); //Unique_ID
aus dem Cursor auslesen

... // Unique-ID verarbeiten
}

cursor.close(); //Cursor schlieen um Speicher freizugeben

Listing 21: Beispiel Datenbankabfrage auf die Unique-ID einer Kontaktart
Die Methode query() liefert als Ergebnis einen Cursor zurck, in dem das
Ergebnis der Abfrage enthalten ist. Der zurckgegebene Cursor ist immer vor dem
ersten Element der Ergebnismenge positioniert. Durch die while-Schleife
while(cursor.moveToNext()) werden alle Zeilen, die als Ergebnis der Abfrage
zurckgegeben werden, durchlaufen. Der Cursor wird nicht automatisch
geschlossen und muss, wenn er nicht mehr bentigt wird, mit cursor.close();
explizit aus dem Speicher bereinigt werden.

6.3 Das Konzept der Klasse LoaderManager
Bei der Darstellung von groen Datenmengen einer Datenbankabfrage ist es in
den meisten Fllen nicht sinnvoll, alle Daten auf einmal aus einem Cursor
auszulesen, zwischenzuspeichern und darzustellen. Diese Vorgehensweise wre
sehr speicher- und zeitintensiv, da jeweils nur ein Bruchteil der Daten auf dem
Bildschirm sichtbar ist. Die restlichen ungenutzten Daten wrden unntig viel
Speicherplatz verbrauchen.
Um solch eine Situation zu vermeiden, stellt Android ein Loader-Framework zur
Verfgung. Mit diesem ist es mglich, nur diejenigen Daten aus der Datenbank zu
laden, die momentan zum Anzeigen auf dem Bildschirm ntig sind. Wird innerhalb
der Liste gescrollt, werden alle bentigten Daten aus der Datenbank nachgeladen.
Dieses Konzept ist sehr ressourcenschonend und zum Anzeigen von groen

48

Datenmengen entwickelt worden.
Um ein solches Konzept zu realisieren, wird zunchst eine Klasse bentigt, die
das Interface LoaderManager.LoaderCallbacks<Cursor> implementiert und dessen
Methoden berschreibt. Diese sind:

@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args)
{
return null;
}

@Override
public void onLoaderReset(Loader<Cursor> loader)
{

}

@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor)
{

}

Listing 22: Zu implementierende Methoden des Interface
LoaderManager.LoaderCallbacks<Cursor>

Innerhalb der Methode onCreateLoader ist das eigentliche Laden der Daten aus der
Datenbank zu realisieren. In den Methoden onLoaderReset und onLoadFinished wird
der momentane Cursor zurck- bzw. neu gesetzt. Ein Beispiel ist anhand der
Klasse ListFragmentFirmenUebersicht in Listing 23 dargestellt.
Um die geladenen Daten in einem ListFragment darzustellen, wird ein neuer
Adapter bentigt. Da es sich in diesem Fall um eine Datenbankabfrage handelt,
die einen Cursor als Ergebnis zurck liefert, kann ein SimpleCursorAdapter
verwendet werden. Dieser wird bereits vom Android-Framework bereitgestellt (ein
Beispiel fr die Implementierung des Cursor-Adapters mit anschlieendem Starten
des Ladevorganges ist in Listing 24 dargestellt).

49

private SimpleCursorAdapter cursorAdapter;

...

@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args)
{
CursorLoader cursorLoader = null; //CursorLoader Objekt erzeugen

cursorLoader = new CursorLoader(context,
ContactsContract.RawContacts.CONTENT_URI, null,
ContactsContract.RawContacts.SYNC2 + "=?", new String[] {"1"}, null);
//Gleiche Vorgehensweise wie bei einer normalen Datenbank Query, mit
dem Unterschied, dass bei einem CursorLoader zustzlich der Context
bergeben werden muss.
return cursorLoader;
}

@Override
public void onLoaderReset(Loader<Cursor> loader)
{
cursorAdapter.swapCursor(null); //Setzt den aktuellen Cursor auf null
}

@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor)
{

cursorAdapter.swapCursor(cursor); //Ersetzt den aktuellen Cursor
}

Listing 23: Implementierte Methoden des Interface
LoaderManager.LoaderCallbacks<Cursor>

private SimpleCursorAdapter cursorAdapter;
private static final int INIT_CURSOR = 0;

[]

//Datenbankfelder die den entsprechenden Elementen des Layouts zugeordnet werden
String[] from = {ContactsContract.RawContacts.DISPLAY_NAME_PRIMARY,
ContactsContract.RawContacts.CONTACT_ID};

//Layoutelemente die von den Daten innerhalb der Spalten from beschrieben werden
int[] to = {R.id.TextViewAnzeigenameVorschau, R.id.imageViewFotoThumbnail};

//Neues CursorAdapter Objekt erzeugen und initialisieren
cursorAdapter = new SimpleCursorAdapter(context,
R.layout.layout_anzeige_bildundname, null, from, to);

//Ladevorgang starten
getLoaderManager().restartLoader(INIT_CURSOR, null, this);

Listing 24: Initialisieren des SimpleCursorAdapter und Starten des Ladevorgangs

50

6.4 Die Methode setViewBinder()
Bei der Verwendung von Standard-Adaptern ist es manchmal ntig, die aus der
Datenbank ausgelesenen Daten noch einmal zu verndern bevor sie innerhalb der
Anwendung dargestellt werden.
In Listing 24 wird bei der Initialisierung des cursorAdapter eine Tabellenspalte
einem Element innerhalb einer Layout-Ressource zugeordnet. Dies geschieht mit
den Variablen from und to. Das heit, dass der Adapter die in dem Cursor
enthaltenen Daten (from) ausliest und diese in ein Element (to) innerhalb der
Layout-Ressource schreibt. In diesem Beispiel wird dem Datenbankfeld
ContactsContract.RawContacts.CONTACT_ID das Element
R.id.imageViewFotoThumbnail zugeordnet. Das Datenbankfeld beinhaltet allerdings
nur Daten vom Typ Long. Bei dem Layout-Element handelt es sich um eine
Image-View, die mit diesem Datentyp nicht umgehen kann. Somit ist es an dieser
Stelle zwingend erforderlich die CONTACT_ID vom Typ Long in ein fr die Image-
View brauchbares Datenformat umzuwandeln. Dies geschieht dadurch, dass das
Bild des Kontaktes aus dem Telefonbuch mit der ID CONTACT_ID aus der Datenbank
geladen und der Image-View bergeben wird.
Zu diesem Zweck stellt Android die Methode setViewBinder(...) zur Verfgung.
Mit dieser ist es mglich, aus der Datenbank kommende Daten abzufangen und
zu verndern. In Listing 25 ist eine beispielhafte Implementierung dieser Methode
dargestellt.
cursorAdapter.setViewBinder(new SimpleCursorAdapter.ViewBinder()
{
@Override
//Die Methode setViewValue(...) der Inneren Klasse
SimpleCursorAdapter.ViewBinder() berschreiben
public boolean setViewValue(View view, Cursor cursor, int columnIndex)
{
if(view.getId() == R.id.imageViewFotoThumbnail)
{
Bitmap foto;
//An dieser Stelle das Bild aus der Datenbank laden
[]
//Die vollstndige Implementierung dieser Methode findet sich
In der Klasse ListFragmentFirmenUebersicht Im Anhang B
auf der CD.
ImageView iv = (ImageView) view;
iv.setImageBitmap(foto); //Das geladene Bild setzen
return true;
}
return false;
}
});

Listing 25: Implementierung der Methode setViewBinder(...)

51

7 Fazit und Ausblick
Nach dem Fertigstellen dieser Diplomarbeit lsst sich feststellen, dass alle
Anforderungen an die entwickelte Software erfllt wurden und eine bersichtliche
und stabile App fr das Betriebssystem Android entstanden ist. Durch erweiterte
Tests der Anwendung durch mehrere Mitarbeiter kann davon ausgegangen
werden, dass die Applikation weitestgehend fehlerfrei ist.
Vor der Inbetriebnahme und Verffentlichung der App mssen noch einige
wichtige Erweiterungen implementiert werden, die zwar im Rahmen dieser
Diplomarbeit nicht gefordert waren, aber fr einen sinnvollen Einsatz der
Applikation unerlsslich sind.
Ein wichtiger Punkt, der zum Abschluss dieser Diplomarbeit noch nicht
einwandfrei funktionierte, ist die Neuanlage und Bearbeitung von synchronisierten
Ansprechpartnern innerhalb des Telefonbuchs. Diese werden zwar korrekt
angezeigt, knnen aber nicht verndert werden. Hier war zu erwarten, dass zu
diesem Zweck die Android eigenen Standard-Eingabeformulare verwendet werden
knnen. Allerdings musste festgestellt werden, dass dies nicht der Fall war.
Stattdessen wirft das Betriebssystem eine EmptyClassException, die anzeigt,
dass an dieser Stelle wohl eine eigene Activity zum Bearbeiten der
Ansprechpartner implementiert werden muss.
Des Weiteren ist die Anmeldung des Synchronisations-Kontos an dem Cloud-
Server noch nicht vollstndig funktionsfhig. Hier fehlt eine serverseitige
Anmeldung mittels Benutzername und Passwort, wodurch eine eindeutige
Unterscheidung der jeweiligen Benutzer erreicht wird.
Zur sicheren Synchronisierung der Daten zwischen dem Cloud-Server und den
Endgerten ist noch eine Verschlsselung der Daten ntig. Dies knnte zum
Einen ber eine SSL verschlsselte Verbindung realisiert werden, was allerdings
mit weiteren Kosten fr ein SSL-Zertifikat verbunden ist. Eine andere Mglichkeit
wre, die Daten mithilfe eines durch den Benutzer festgelegten Passworts bereits
auf dem Gert zu verschlsseln und anschlieend zu versenden. Der groe
Vorteil an dieser Lsung wre, dass alle Daten verschlsselt auf dem Cloud-
Server vorliegen wrden, was eine zustzliche Sicherheit gewhrt. Fr eine
maximale Sicherheit knnte man diese beiden Methoden verbinden und die
bereits verschlsselten Daten ber eine SSL- verschlsselte Verbindung senden.

52

Weiterhin sind noch kleinere Optimierungen denkbar. Beispielsweise knnten
Dateien, die whrend des Synchronisationsvorganges bereits vollstndig geladen
wurden, in einem neuen Thread gleichzeitig in die Datenbank geschrieben
werden. Dadurch wrde das Laden der Dateien und Schreiben der geladenen
Informationen nicht mehr nacheinander (seriell) erfolgen, sondern parallel
abgearbeitet werden, was einen Geschwindigkeitsvorteil bewirken wrde. Zudem
sollte das Fehlerhandling bei Verbindungsabbrchen whrend der Synchronisation
weiter optimiert werden. Momentan werden nur fehlerhafte XML-Datenstrme
berprft und erneut angefordert. Dieses Verhalten sollte auch auf
heruntergeladene Dateien bertragen werden.
Mit dem Abschluss dieser Diplomarbeit ist der Grundstein fr die mobile Strategie
fr das CRM und DMS der Prisma GmbH gelegt. Im direkten Anschluss an diese
Diplomarbeit werden die fr die Marktreife bentigten Elemente schnellstmglich
realisiert, um die Produktpalette UpToNet

sinnvoll zu erweitern.

53

Literaturverzeichnis

Bcher:
[1] Mike Bach: Mobile Anwendungen mit Android - Entwicklung und
Praktischer Einsatz. 1. Auflage, Addison Wesley, Mnchen 2012
[2] Thomas Knneth: Android 4 Apps entwickeln mit dem Android
SDK. 2. Aktualisierte und erweiterte Auflage, Galileo Press, Bonn
2012

Internetquellen:
[3] http://de.wikipedia.org/wiki/App
(Stand: 03.September 2012)
[4] http://de.wikipedia.org/wiki/Smartphone
(Stand: 03.September 2012)
[5] http://de.wikipedia.org/wiki/Tablet-Computer
(Stand 03.September 2012)
[6] http://de.wikipedia.org/wiki/Cloud-Computing
(Stand 03.September 2012)
[7] http://www.test.de/Tablet-Rechner-Einer-besser-als-das-iPad-
4304701-0/ (Stand: 10.September 2012)
[8] http://en.wikipedia.org/wiki/Android_version_history
(Stand: 04.September 2012)
[9] http://developer.android.com/about/dashboards/index.html
(Stand: 04.September 2012)
[10] http://source.android.com/tech/security/images/image00.png
(Stand 09.September 2012)
[11] http://developer.android.com/guide/topics/ui/index.html
(Stand: 03.September 2012)
[12] http://android-developers.blogspot.de/2012/01/say-goodbye-to-
menu-button.html (Stand 08. September 2012)

54

[13] http://de.wikipedia.org/wiki/Model_View_Controller
(Stand 15.September 2012)
[14] http://de.wikipedia.org/wiki/SQLite
(Stand 17. September 2012)
[15] http://www.sqlite.org/omitted.html
(Stand 17. September 2012)













Anhang A

I

Abbildungsverzeichnis Anhang A


Abb 1. Neue Elemente auf der Menleiste in Eclipse ........................................... 1
Abb 2. Import Dialog Auswahl der Importmethode ............................................. 3
Abb 3. Import Dialog Auswahl des Projektes ..................................................... 3
Abb 4. Android Virtual Device Manager ................................................................ 4
Abb 5. Dialog zum Anlegen eines neuen Emulators ............................................. 5
Abb 6. Menpunkt Debug Configurations ........................................................... 6
Abb 7. Anlegen einer Debug-Konfiguration ........................................................... 7
Abb 8. Manuelle Auswahl des Zielgertes festlegen ............................................. 7
Abb 9. Package Explorer ...................................................................................... 8
Abb 10. Grafischer Layout Editor .......................................................................... 10
Abb 11. Ein einfaches Layout mit einer TextView und einem Button .................... 11
Abb 12. Eine Auswahl an Layout Elementen auf einen Blick ................................ 13
Abb 13. Der Lebenszyklus einer Activity ............................................................... 15
Abb 14. Fragmente auf unterschiedlichen Endgerten ......................................... 16
Abb 15. Lebenszyklus eines Fragments ............................................................... 17
Abb 16. Status der Activity, bezogen auf den Lebenszyklus des Fragments ........ 17
Abb 17. Dialog Fragment ...................................................................................... 18
Abb 18. Motorola Xoom Tablet.............................................................................. 20



II

Inhaltsverzeichnis Anhang A

1 Installation der Komponenten ....................................................................... 1
2 Inbetriebnahme des Projektes ....................................................................... 2
2.1 Import des Projektes .................................................................................. 2
2.2 Installation der Gertetreiber ...................................................................... 4
2.3 Anlegen eines Emulators ........................................................................... 4
2.4 Die Applikation ausfhren .......................................................................... 6
3 Grundlagen der Android-Softwareentwicklung ........................................... 8
3.1 Die Projektstruktur...................................................................................... 8
3.2 Layout-Ressourcen .................................................................................. 10
3.3 Activity ...................................................................................................... 14
3.4 Fragmente ................................................................................................ 16
4 Unique-Id ....................................................................................................... 19
5 Das Motorola Xoom Tablet .......................................................................... 20



1

1 Installation der Komponenten
Fr die Android-Entwicklung werden folgende Komponenten bentigt:
- Eclipse ( http://www.eclipse.org/downloads/ )
- Java (JDK) vorzugsweise in der Version 1.6
( http://www.oracle.com/technetwork/java/javase/downloads/index.html )
- Android SDK ( http://developer.android.com/sdk/index.html )
- ADT Plug-In fr Eclipse
( http://developer.android.com/sdk/installing/installing-adt.html )
Alle bentigten Komponenten (mit Ausnahme des ADT-Plug-In) fr eine 32 und 64
Bit Windows-Installation sind auf der beigefgten CD im Anhang B vorhanden.
Das ADT-Plug-In fr Eclipse wird nicht ber einen Installer, sondern mit Hilfe von
so genannten Update-Sites installiert. Eine Installationsanleitung findet sich unter
folgender URL: http://developer.android.com/sdk/installing/installing-adt.html
(Stand 09.09.2012). Das ADT-Plug-In bietet eine optimale Integration des SDK in
die Entwicklungsumgebung Eclipse.
Hinweis: Die Installation des Android SDK kann mitunter mehrere Stunden andauern.
Dies ist von den zur Installation ausgewhlten Android-Versionen abhngig. Jede dieser
Version besitzt einen eigenen Emulator, wodurch die Installation mehrere Gigabyte
Speicherplatz in Anspruch nehmen kann.
Nach der Installation des ADT-Plug-In stehen in Eclipse neue Funktionen zum
Anlegen und Bearbeiten von Android-Projekten zur Verfgung. Die wichtigsten
Android-Elemente werden standardmig in der Menleiste angezeigt (siehe
Abbildung 1).

Abb 1. Neue Elemente auf der Menleiste in Eclipse


2

- SDK-Manager: Hier lassen sich neue Android-Versionen, Updates und
Treiber herunterladen und installieren.
- AVD-Manager: Der Android Virtual Device-Manager dient dem Anlegen und
Bearbeiten von virtuellen Android-Gerten. Diese knnen innerhalb der
Entwicklungsumgebung als Emulatoren zum Testen der Applikation
verwendet werden.
- New Project: An dieser Stelle kann ein neues Android-Projekt angelegt
werden. Hierbei wird man durch ein Men geleitet, welches einem die
Konfiguration des Projektes erleichtert.
- New Test Project: Mit einem Test-Projekt lsst sich eine entwickelte
Applikation mit automatisierten Mechanismen testen. Dies ist vorteilhaft bei
Komponenten, die keine sichtbaren Elemente besitzen und mit Hilfe des
Emulators nur schwierig zu testen sind (beispielsweise Content-Provider)
20
.
- New XML-File: Hier lassen sich neue Ressource-Dateien wie Layouts,
Animationen oder Mens anlegen.
2 Inbetriebnahme des Projektes
2.1 Import des Projektes
Nach der erfolgreichen Installation der bentigten Komponenten kann das auf der
CD befindliche Projekt UpToNetApp importiert werden. Hierzu whlt man in der
Entwicklungsumgebung Eclipse unter der Rubrik File den Menpunkt Import.
Im sich ffnenden Dialog whlt man unter dem Ordner General den Eintrag
Existing Projects into Workspace (siehe Abbildung 2).
Im darauf folgenden Fenster kann das Projekt nun importiert werden. Dazu ist das
Verzeichnis des Projektes in der Spalte Select root directory anzugeben. Dieses
befindet sich auf der beigefgten CD unter dem Ordner Mobiles Bro
Quelldateien. Nach Auswahl des Dateipfades erscheinen in dem Feld Projects
alle importierbaren Projekte. Nach Auswahl des Projektes ist es wichtig, einen
Haken in dem Feld Copy projects into workspace zu setzen, da ansonsten nur
eine Verknpfung zu dem Projekt erzeugt werden wrde (siehe Abbildung 3).

20
Quelle: http://www.vogella.com/articles/AndroidTesting/article.html (Stand: 09. September 2012)

3


Abb 2. Import Dialog Auswahl der Importmethode


Abb 3. Import Dialog Auswahl des Projektes

4

2.2 Installation der Gertetreiber
Nach dem erfolgreichen Import des Projektes in den Eclipse-Workspace, kann die
Applikation nun ausgefhrt werden. Zu diesem Zweck wird entweder ein realer
Tablet-Computer oder ein entsprechender Emulator mit der Android-Version 3.2+
bentigt.
Bei der Verwendung eines realen Endgertes ist dieses zunchst ber ein USB-
Kabel mit dem PC zu verbinden. Anschlieend mssen die neuesten Treiber des
Gertes installiert werden. Mit der Installation des SDK-Managers wurden bereits
USB-Treiber fr die gngigsten Gerte installiert. Sollten sich die Treiber nach
Anschluss des Gertes nicht automatisch installieren kann die Angabe des SDK-
Dateipfades bei der Treibersuche evtl. Abhilfe verschaffen. Konnten auch
innerhalb dieses Ordners keine passenden Gertetreiber gefunden werden, so
finden sich auf der Android-Entwickler-Homepage
21
Treiber verschiedenster
Gertehersteller.
2.3 Anlegen eines Emulators
Steht kein reales Gert zum Testen der Applikation zu Verfgung, so kann mit
Hilfe des AVD-Managers ein neuer Emulator erzeugt werden, der ein reales Gert
1:1 simuliert. Hierzu klickt man innerhalb von Eclipse auf der Menleiste das Icon
(AVD-Manager) wodurch sich ein neues Men ffnet, in dem man die
Mglichkeit hat, Emulatoren anzulegen und zu verwalten (siehe Abbildung 4).

Abb 4. Android Virtual Device-Manager

21
http://developer.android.com/tools/extras/oem-usb.html (Stand 09.09.2012)

5

Durch einen Klick auf den Button New ffnet sich ein neuer Dialog zum
Anlegen eines neuen Emulators (siehe Abbildung 5).

Abb 5. Dialog zum Anlegen eines neuen Emulators
Innerhalb des Feldes Name kann dem Emulator ein beliebiger Name gegeben
werden. Unter Target wird dem Emulator eine Android-Betriebssystemversion
zugewiesen. In der Eingabemaske SD Card kann dem virtuellen Gert eine SD-
Karte als zustzlicher Speicher hinzugefgt werden. Durch die Checkbox
Snapshot kann eine Momentaufnahme des Emulators auf der Festplatte
gespeichert werden. Innerhalb der Eingabemaske Skin kann nach Bedarf die
Gre des Emulators festgelegt werden. Unter dem Punkt Hardware knnen
dem Emulator bestimmte, virtuelle Hardwarekomponenten hinzugefgt werden
(beispielsweise eine Kamera, Hardware-Buttons oder eine GPS Untersttzung,
etc.).
Hinweis: Bei der Verwendung von GPS kann entweder ein fest vorgegebener Standort
simuliert oder es knnen KML- oder GPX-Dateien
22
abgespielt werden.

22
Bei KML und GPX Dateien handelt es sich um ein Dateiformat zur Speicherung von Geodaten,
wodurch eine zurckgelegte Route simuliert werden kann. Weitere Informationen finden sich unter:
http://de.wikipedia.org/wiki/Keyhole_Markup_Language (Stand 11. September 2012) oder
http://de.wikipedia.org/wiki/GPS_Exchange_Format (Stand 11. September 2012)

6

2.4 Die Applikation ausfhren
Nachdem nun ein reales oder virtuelles Gert vorhanden ist, kann die Applikation
im Debug-Modus gestartet werden. Dazu ist es ratsam eine neue Debug-
Konfiguration fr dieses Projekt anzulegen. Hierzu whlt man unter dem
Menpunkt Run den Unterpunkt Debug Configurations (siehe Abbildung 6).

Abb 6. Menpunkt Debug Configurations
Im sich ffnenden Dialog whlt man im linken Bereich den Punkt Android
Applikation und legt mit dem Icon (New launch configuration) eine neue Debug-
Konfiguration an. Im rechten Bereich des Dialogs vergibt man der Konfiguration
einen eindeutigen Namen und whlt unter Project das UpToNetApp Projekt aus
(siehe Abbildung 7). Im letzten Schritt setzt man innerhalb des Reiters Target
den Deployment Target Selection Mode auf manual (siehe Abbildung 8).
Dadurch wird vor jedem Debug-Vorgang ein Dialog zur Auswahl des Zielgertes
angezeigt.
Durch einen Klick auf Debug und anschlieender Auswahl des Zielgertes wird
die Applikation auf dem gewhlten Gert installiert und im Debug-Modus gestartet.
Das Debuggen einer Android-Applikation gestaltet sich wie bei einer normalen
Java-Anwendung und wird aus diesem Grund nicht weiter erlutert.

7


Abb 7. Anlegen einer Debug-Konfiguration

Abb 8. Manuelle Auswahl des Zielgertes festlegen

8

3 Grundlagen der Android-Softwareentwicklung
3.1 Die Projektstruktur

Abb 9. Package-Explorer

In dem in Abbildung 9 dargestellten Package-Explorer ist die Struktur eines
Android-Projektes zu erkennen. Unterhalb des Ordners src befinden sich, in
verschiedene Pakete unterteilt, alle bentigten Java-Quellen.
In dem Ordner gen werden alle bentigten Ressourcen-IDs innerhalb der Klasse
R.java abgelegt. Dabei handelt es sich um eine automatisch erzeugte Klasse, in
der keine nderungen vorzunehmen sind.

9

Der Ordner Android 3.2 beinhaltet alle Bibliotheken, die zur Ausfhrung der
Applikation bentigt werden.
Innerhalb des Ordners Assets knnen beliebige Dateien abgelegt werden. Auf
diese wird im Gegensatz zu Ressourcen nicht ber eine Konstante ID, sondern mit
dem Dateinamen zugegriffen. Diese Dateien werden bei Auslieferung der
Applikation ohne weitere Optimierung 1:1 bernommen.
Der Ordner bin wird ebenfalls wie der Ordner gen automatisch erzeugt. Hier
sind ebenfalls keine nderungen vorzunehmen.
Alle Ressource-Dateien befinden sich innerhalb des Ordners res. Hierbei handelt
es sich beispielsweise um Layouts, Mens, Animationen, Strings etc. Fr alle
Ressourcen werden Identifizierer in Form von Konstanten in der Klasse R.java
angelegt. Mit Hilfe dieser Konstanten kann innerhalb des Quellcodes auf die
Ressourcen zugegriffen werden.
Das Herzstck einer Applikation bildet das AndroidManifest.xml. Innerhalb dieser
speziellen Ressource-Datei werden die Grundbestandteile einer Applikation
deklariert. Im Folgenden sind die wichtigsten Elemente genannt:
- Activitys: Eine Bildschirmseite der Applikation (siehe Kapitel 3.3).
- Services: Ein Dienst, der im Hintergrund der Applikation ausgefhrt wird.
- Content-Provider: Ermglicht anderen Anwendungen auf die
applikationseigene Datenbank zuzugreifen.
- Permissions: Berechtigungen ber die innerhalb der Applikation
verwendeten Elemente (Bsp.: Internet, Telefonie, Kontakte auslesen,
Kontakte schreiben etc.). Diese Berechtigungen sind ffentlich und mssen
vor der Installation der Applikation auf dem Endgert durch den Benutzer
besttigt werden. Dabei ist es nicht mglich nur einen Teil der
Berechtigungen zu akzeptieren und andere nicht. Demnach mssen vor der
Installation ausnahmslos alle Berechtigungen akzeptiert werden.
- Intent-Filter: Deklariert zum einen den Startpunkt der Applikation und zum
anderen wird hierdurch festgelegt, mit welcher Art von Dateitypen die
Applikation umgehen kann.


10

3.2 Layout-Ressourcen
Layout-Ressourcen definieren bei der Android-Softwareentwicklung die
Oberflchen fr Activitys oder eigene Benutzerinterface-Komponenten. Die
Deklaration erfolgt mit Hilfe von XML-Dateien, die im Verzeichnis res/layout
angelegt werden. Diese Dateien knnen auf zwei unterschiedliche Arten
bearbeitet werden. Zum Einen ist es mglich, alle Elemente in reinem XML zu
beschreiben. Zum Anderen stellen die Android Development Tools einen eigenen
Layout-Editor zur Verfgung, der einem besonders zu Beginn der Android-
Programmierung die Erstellung eines Layouts erleichtert. Hierbei handelt es sich
um einen grafischen Editor, mit dem man das Layout per Drag-und-Drop aufbauen
kann (siehe Abbildung 10). Dieser macht allerdings im Hintergrund nichts anderes,
als alle Elemente, die man grafisch angeordnet hat, in ein XML-Dokument
umzuwandeln. Somit wird dem Entwickler ein wenig Schreibarbeit erspart,
allerdings stt der Editor sehr schnell an seine Grenzen, wenn das Layout
komplexer wird.

Abb 10. Grafischer Layout Editor

11

In einer Layout-Ressource werden alle Elemente wie z.B. Buttons, Bilder,
Textfelder etc. innerhalb einer View bzw. einer Ableitung dieser Klasse deklariert.
Dazu stellt Android mehrere Klassen zur Verfgung, die die Anordnung dieser
Elemente bestimmen. Die Wichtigsten sind:
- LinearLayout (Vertical):
Alle beinhalteten Elemente werden untereinander angeordnet.
- LinearLayout (Horizontal):
Alle beinhalteten Elemente werden nebeneinander angeordnet.
- RelativeLayout:
Alle beinhalteten Elemente werden relativ zu anderen Elementen platziert.
- FrameLayout:
Innerhalb eines FrameLayouts knnen Elemente whrend der Laufzeit
hinzugefgt und ausgetauscht werden.
Dabei ist auch eine Kombination mehrerer Views mglich. Beispielsweise kann ein
vertikales LinearLayout ein horizontales LinearLayout beinhalten. Dadurch ist jede
denkbare Anordnung der Elemente mglich. Ein Beispiel eines einfachen Layouts
mit einem Feld zum Anzeigen von Text (TextView) und einem Knopf (Button) ist in
Abbildung 11 dargestellt.

Abb 11. Ein einfaches Layout mit einer TextView und einem Button
Listing 1 zeigt das Layout aus Abbildung 11 in XML-Schreibweise.


12

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >

<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/TextView"
android:textAppearance="?android:attr/textAppearanceLarge" />

<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/einButton" />

</LinearLayout>

Listing 1: Layout Ressource in XML-Schreibweise
Eine Layout Ressource beginnt immer mit der Zeile <?xml version="1.0"
encoding="utf-8"?>. Diese legt die verwendete XML-Version und das Encoding
fest. Als Nchstes folgt eine, alles umschlieende View bzw. ein LinearLayout.
Dieses bestimmt die Anordnung der beinhalteten Elemente. Jedes Element
beginnt mit einem Kleinerzeichen (<) gefolgt vom Namen des Elements. Hinter
dem Namen knnen jedem Element verschiedene Attribute hinzugefgt werden.
Solche Attribute sind beispielsweise android:id (Identifizierer des Elements),
android:layout_width (Breite des Elements), android:layout_height (Hhe des
Elements), android:orientation (vertikale oder horizontale Ausrichtung),
android:background (Hintergrund des Elements) etc. Ein Element kann auf zwei
unterschiedliche Arten wieder geschlossen werden.
Handelt es sich um ein Element, welches andere Elemente umschliet
(beispielsweise ein LinearLayout), so verwendet man ein Schlieen-Tag mit dem
jeweiligen Elementnamen </LinearLayout>. Der Unterschied zu einem ffnen-
Tag ist der Schrgstrich (/) hinter dem Kleinerzeichen.
Alle anderen Elemente, knnen mit einem Schrgstrich, gefolgt von einem
Grerzeichen geschlossen werden (/>).
In Abbildung 12 ist eine Auswahl an Elementen zum Gestalten eines Layouts
dargestellt.

13


Abb 12. Eine Auswahl an Layout Elementen auf einen Blick
Um die Gre eines Elementes festzulegen, werden die Attribute
android:layout_width und android:layout_height verwendet. Diesen Attributen
knnen unterschiedliche Werte zugewiesen werden. Diese sind:
- match_parent: Passt die Gre des Elements an das umgebene Element
an (z. B. an ein umgebenes LinearLayout). Existiert kein solches
umgebenes Element, so wird es an die Bildschirmgre angepasst.
- wrap_content: Passt die Gre an den Inhalt des Elementes an. Handelt es
sich beispielsweise um einen Button, so wird dieser so gro, dass er den
beinhaltenden Text anzeigen kann.
- dp: Density-independent Pixel ist eine bildschirmunabhngige
Grenangabe. Dabei entspricht 1dp einem Pixel auf einem 160dpi
Bildschirm. Die Umwandlung von dp zu Pixeln berechnet sich
folgendermaen
23
: |
.
|

\
|
=
160
dpi
dp px . Die Angabe von Gren in dp ist
anderen Grenangaben wie z.B. px (Pixel) oder mm (Millimeter)
vorzuziehen, da hierbei alle Elemente auf unterschiedlich groen
Bildschirmen den gleichen Platz beanspruchen.

23
Quelle: http://developer.android.com/guide/practices/screens_support.html (Stand 10.09.2012)

14

3.3 Activity
Eine Activity ist eine Bildschirmseite auf einem mobilen Endgert, mit der der
Benutzer interagieren kann. Eine Applikation muss aus mindestens einer, kann
aber durchaus auch aus mehreren Activitys bestehen.
Dabei reagiert die Activity auf Benutzereingaben, ffnet Netzwerk- und
Datenbankverbindungen, startet andere Activitys etc. Sie ist so zu sagen die
Schaltzentrale, die das Zusammenspiel der einzelnen Elemente koordiniert.
Eine Activity ist eine Java-Klasse, die von der Elternklasse Activity erbt. Das
Aussehen wird mit Hilfe einer Layout-Ressource bestimmt.
Der Aufbau einer Activity gleicht einer normalen Java-Klasse. Zunchst wird mit
package com.prisma.uptonet; das Paket deklariert, in dem sich die Klasse befindet.
Es folgen etwaige Import-Anweisungen von fremden Klassen, die innerhalb der
Activity verwendet werden (Listing 2).
import android.app.ActionBar;
import android.app.ActionBar.Tab;
import android.app.ActionBar.TabListener;
import android.content.Intent;

Listing 2: Import externer Klassen
Als Nchstes wird die Klasse selbst deklariert.
public class UpToNetAppActivity extends Activity implements TabListener

Listing 3: Deklaration der Klasse UpToNetAppActivity
Das Schlsselwort extends kennzeichnet die Elternklasse, von der geerbt wird.
Das Schlsselwort implements kennzeichnet alle Interfaces, die durch die Activity
implementiert werden.
Die Elternklasse Activity besitzt Methoden, die innerhalb der eigenen Activity
berschrieben werden knnen. Die berschriebenen Methoden werden durch die
Annotation @Override gekennzeichnet. Durch das berschreiben hat man die
Mglichkeit, in verschiedene Lebenszyklen einer Activity einzugreifen und auf
diese zu reagieren. Abbildung 13 zeigt den Lebenszyklus
24
einer Activity.

24
Quelle: http://developer.android.com/guide/components/activities.html (Stand 10.09.2012)

15


Abb 13. Der Lebenszyklus einer Activity
Nachdem eine Activity gestartet wurde, wird die Methode onCreate() aufgerufen.
Diese wird dazu verwendet der Activity ein Layout zuzuweisen oder
unterschiedliche Objekte zu initialisieren. Zu diesem Zeitpunkt ist die Activity noch
nicht sichtbar. Der gesamte Lebenszyklus der Activity liegt zwischen den
Methoden onCreate() und onDestroy().
Die Methode onStart() wird aufgerufen, wenn die Activity sichtbar wird. Der fr
den Benutzer sichtbare Lebenszyklus liegt zwischen den Methoden onStart()und
onStop(). Letztere wird aufgerufen, wenn die Activity nicht mehr sichtbar ist, weil
beispielsweise eine andere Activity gestartet wurde.
Die Methode onPause() wird aufgerufen, wenn die Activity kurz davor ist aus dem
sichtbaren Bereich zu verschwinden. Sobald die Activity wieder sichtbar wird und
kurz davor steht Interaktionen durch den Benutzer zuzulassen, wird die Methode
onResume() aufgerufen.

16

3.4 Fragmente
Fragmente wurden mit der Android-Version 3 eingefhrt und bestehen aus einer
eigenen Klasse, die von der Elternklasse Fragment erbt. Fragmente besitzen ein
eigenes Layout und mssen immer in eine Activity eingebettet werden. Innerhalb
einer Activity knnen mehrere Fragmente kombiniert werden, was vor allem auf
Tablet-Computern durch den zur Verfgung stehenden Platz sinnvoll ist. Der
groe Vorteil von Fragmenten ist, dass sie whrend der Laufzeit der Applikation
gegen andere Fragmente ausgetauscht werden knnen und dadurch in der Lage
sind, der Activity eine ganz neue Funktion zu geben. Ein weiterer Vorteil ist, dass
es durch die Verwendung von Fragmenten vereinfacht wird, eine fr ein Tablet
entwickelte App auch auf einem Smartphone einzusetzen. Abbildung 14 soll dies
verdeutlichen
25
.

Abb 14. Fragmente auf unterschiedlichen Endgerten
Ein Fragment hat ebenso wie eine Activity einen eigenen Lebenszyklus. Dieser ist
in Abbildung 15 dargestellt
26
. In Abbildung 16 wird der jeweilige Status der Activity,
bezogen auf den Lebenszyklus des Fragmentes, verdeutlicht
27
.

25
Quelle: http://developer.android.com/guide/components/fragments.html#Design
(Stand 11.09.2012)
26
Quelle: http://developer.android.com/guide/components/fragments.html#Creating
(Stand 11.09.2012)
27
Quelle: http://developer.android.com/guide/components/fragments.html#Lifecycle
(Stand 11.09.2012)

17



Abb 15. Lebenszyklus eines
Fragments
Abb 16. Status der Activity, bezogen auf den
Lebenszyklus des Fragments







18

Neben der Basisklasse Fragment stellt das Android-Framework mehrere
abgeleitete Klassen zur Verfgung
28
. Diese sind:
- DialogFragment: Mit Hilfe eines DialogFragment lsst sich ein kleines
Fenster anzeigen, dass sich vor die aktuelle Activity schiebt (siehe
Abbildung 17). Dieses lsst sich beispielsweise zum Anzeigen von
Warnungen oder zum Eingeben von Text einsetzen.
- ListFragment: Mit einem ListFragment lassen sich Daten mit Hilfe einer
Liste darstellen.
- PreferenceFragment: Mit einem PreferenceFragment lassen sich
Einstellungen mit Hilfe einer Liste darstellen.

Abb 17. Dialog Fragment


28
Quelle: http://developer.android.com/guide/components/fragments.html#Creating
(Stand 09.12.2012)

19

4 Unique-Id
Eine Unique-Id bzw. Universally Unique Identifier (UUID) bezeichnet eine
weltweit eindeutige 128-Bit lange Zahl
29
. Damit diese Zahl wirklich einzigartig ist,
wird sie aus der Systemzeit und der MAC-Adresse der Netzwerkkarte gebildet.
Besitzt ein System keine Netzwerkkarte, so wird anstelle der Mac-Adresse ein
pseudozuflliger Wert verwendet
30
.
Eine Unique-Id besitzt die Form a3992569-9762-4613-9763-f61b2dcfcc61.
In dieser Diplomarbeit wurde die Unique-Id dazu verwendet, um Kontakte,
Ansprechpartner, Firmen, Mitarbeiter, Kontaktarten und Anhnge innerhalb
unterschiedlicher Datenbanken eindeutig unterscheiden zu knnen.
Beispielsweise knnte es ohne eine eindeutige ID Probleme verursachen, wenn
ein Ansprechpartner pltzlich einen anderen Nachnamen htte (z.B. durch eine
Heirat). Wrde man diesen, anstelle der Unique-Id, durch den Vor- und
Nachnamen identifizieren, so wre dieser Ansprechpartner nicht mehr ohne
Weiteres in der Datenbank auffindbar.


29
Quelle: http://docs.oracle.com/javase/7/docs/api/java/util/UUID.html (Stand 11.09.2012)
30
Quelle: http://de.wikipedia.org/wiki/Universally_Unique_Identifier (Stand 11.09.2012)

20

5 Das Motorola Xoom Tablet
Die in dieser Diplomarbeit erstellte Applikation Mobiles Bro wurde auf einem
Motorola Xoom Tablet (siehe Abbildung 18) entwickelt und getestet. Im Folgenden
finden sich die technischen Details:

Abb 18. Motorola Xoom Tablet
31

Die wichtigsten technischen Details
32
:
Gre (B/H/T) 249 x 168 x 13 mm
Gewicht 730 g
Display 10,1 Zoll (ca. 26 cm)
Auflsung 1280 x 800 Pixel
Prozessor Typ NVIDIA Tegra 2 AP20H
Prozessor Leistung 1000 MHz mit 2 Kernen

31
Quelle: http://www.blugga.com/wp-content/uploads/2012/01/Motorola-Xoom-Wi-Fi.jpg
(Stand: 15.September 2012)
32
Quelle: http://www.handy-deutschland.de/motorola-xoom-3g-datenblatt.html
(Stand: 15.September 2012)

21

Betriebssystem
Zunchst Android 3.2. Nach Update im August 2012
Android 4.0.4
Interner Speicher 16 GB
Arbeitsspeicher 1 GB DDR2
Kamera Vorderseite 2 Megapixel
Kamera Rckseite 5 Megapixel
Beschleunigungssensor Ja
Lichtsensor Ja















Anhang B


1

Nachfolgend wird der Inhalt der beigefgten CD vorgestellt.
- Diplomarbeit
Diplomarbeit Entwicklung von Komponenten fr ein mobiles Bro unter
dem Betriebssystem Android in elektronischer Form (PDF).

- Eclipse
Eclipse Juno for Java EE Developers 32 Bit Windows-Version
(Stand: 01.September 2012)
Eclipse Juno for Java EE Developers 64 Bit Windows-Version
(Stand: 01.September 2012)

- Java Development Kit (JDK)
Java Development Kit Version 6 Update 35 32 Bit Windows-Version
(Stand: 01.September 2012)
Java Development Kit Version 6 Update 35 64 Bit Windows-Version
(Stand: 01.September 2012)


- Software Development Kit (SDK)-Manager
SDK Manager Version 20.0.3 fr Windows (Stand: 01.September 2012)

- Mobiles Bro Quelldateien
Der Quellcode dieser Diplomarbeit, vorbereitet fr den Import nach
Eclipse.

- Onlinequellen
Alle verwendeten Onlinequellen als .html-Datei