Beruflich Dokumente
Kultur Dokumente
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
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
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
Cloud Modell
Datenstze, die aus dem 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