Android Umgebung einrichten - Berufsschule 7 in Augsburg

Android Umgebung einrichten
Android – Kurs Stufe 1 (Gelbgurt)
Inhaltsverzeichnis
1
Einleitung .................................................................................................................................................. 2
2
Kursaufbau ................................................................................................................................................ 2
3
Aufbau der Entwicklungs-Infrastruktur..................................................................................................... 3
4
Installation der Entwicklungsumgebung ................................................................................................... 3
5
Grundgedanken.......................................................................................................................................... 4
6
HelloWorld – die erste App ....................................................................................................................... 4
7
Testen der Software ................................................................................................................................... 6
8
Die angelegte Struktur ............................................................................................................................... 7
8.1
8.1.1
Die Java Klassen ........................................................................................................................ 7
8.1.2
Die Layout Files ........................................................................................................................ 7
8.2
Die Ressourcen .................................................................................................................................. 8
8.2.1
Grafikdateien ............................................................................................................................. 8
8.2.2
Layout Informationen ................................................................................................................ 8
8.2.3
Allgemeine Werte ...................................................................................................................... 8
8.3
9
Die Main Activity .............................................................................................................................. 7
AndroidManifest.xml ........................................................................................................................ 9
Ein kurzer Blick auf die wichtigsten XML Dateien .................................................................................. 9
9.1
activity_main.xml .............................................................................................................................. 9
9.2
strings.xml ......................................................................................................................................... 9
9.3
AndroidManifest.xml ...................................................................................................................... 10
9.4
ids.xml ............................................................................................................................................. 10
10
Lizenz .................................................................................................................................................. 12
11
Haftung ................................................................................................................................................ 12
AnPr_Android_Course_1_1_Setup_v01.docx
Seite 1
Android Umgebung einrichten
1
Einleitung
AndroidTM ist in aller Munde – oder besser gesagt „in aller Hände“. Dies hat unter anderem mit folgenden
Punkten zu tun:
 Derzeit sind Android Geräte am meisten verbreitet.
 Die Leistungsdaten von Android Geräten sind in jeder Hinsicht konkurrenzfähig.
 Die Einstiegshürden für die Entwicklung von Android sind minimal.
Mit einem fundierten Android Wissen sind sie in einem internationalen Markt gut positioniert und das Beste
daran ist, sie können dabei auch noch jede Menge Spaß haben – von einigen Frustrationsmomenten mal abgesehen, an die hat man sich als Programmierer aber schon gewöhnt.
Dieser Kurs soll helfen, einen Einstieg in die Android Programmierung zu erlangen. Es wurde versucht, die
einzelnen Inhalte möglichst praxisnah aufzubauen – jedoch immer vor dem Hintergrund, dass die Zielgruppe
erst am Anfang ihrer Programmierer-Karriere steht. Der Kurs hat mehrere Stufen, bei denen pro Stufe mehrere inhaltliche Schwerpunkte gesetzt sind. Nach jeder Stufe sollte man in der Lage sein, einen weiteren Meilenstein der Android Programmierung zu meistern.
Folgende Leitgedanken sind bei dem Kurs anzumerken. Dieser Kurs ist…
… kein Garant für Vollständigkeit
… kein Garant für die beste Lösung
… nicht immer 100% „state of the art“
… auf Android 2.3 (Gingerbread) und höher ausgelegt
… eine Sammlung von Erfahrungen, welche ich beim Programmieren gemacht habe
… ein Versuch, die hunderten von kryptischen Foreneinträgen so zusammenzufassen, dass sie schnell
nachvollziehbar sind
… im Wesentlichen für meine Schüler, es ist aber auch nicht verboten den Kurs zu machen, wenn man
nicht in meiner Schule ist 
Zielgruppe des Kurses sind all diejenigen, welche bereits Java Grundkenntnisse haben (Kontrollstrukturen,
einfache und zusammengesetzte Datentypen (Arrays, ArrayList etc.), Objekte, Vererbung und Interfaces.
Diejenigen, welche hier keinerlei Erfahrung haben sollten zumindest die Grundzüge kennengelernt haben.
Hierzu finden Sie ebenfalls unter www.codeconcert.de Anhaltspunkte.
2
Kursaufbau
Zu jeder Stufe finden Sie unter YouTube mehrere Lehrvideos, welche die Inhalte aufbereitet darstellen. Details hierzu entnehmen Sie bitte meiner Webpage (www.codeconcert.de). Wenn für die Beispiele Grafiken
o.Ä. verwendet werden, finden Sie diese Ressourcen ebenfalls in meiner Homepage.
In diesem Dokument werden wir uns mit dem Einrichten einer Entwicklungsumgebung und der Erzeugung
einer einfachen App beschäftigen. Anschließend analysieren wir die von der Entwicklungsumgebung erzeugten Files und Ordner.
Das Folgekapitel „AnPr_Android_Course_1_2_Layouts“ wird das Thema Layouts und Views näher beleuchten. Wenn diese beiden Kapitel durchgearbeitet wurden, sind Sie in der Lage, einfache, grafisch ansprechende Anwendungen zu realisieren. Am Ende jeder Stufe finden Sie eine Aufgabenstellung für eine
App, welche Sie selbstständig realisieren sollen. Eventuelle zusätzliche Ressourcen (wie bspw. Grafiken
Sounds etc.) habe ich auf die Homepage gestellt, so dass Sie sich hierüber keine Gedanken machen müssen.
Seite 2
Android Umgebung einrichten
3
Aufbau der Entwicklungs-Infrastruktur
Android wird mit Hilfe von Java programmiert. Android Geräte „verstehen“ zwar kein Java Bytecode, so
wie ihn der Standard Java Compiler erzeugt, jedoch ist dieser Bytecode die Grundlage für die Erzeugung des
ausführbaren Codes für die Dalvík Virtual Machine. Diese kann man sich zwar vorstellen wie das JRE von
Java, jedoch vom Grundaufbau wurde hier mehr Wert auf die Performancespezifika von mobilen Geräten
gelegt.
Da die Umwandlung vom Sourcecode (*.class Files) über Java Bytecode bis hin zum Dalvík Code (*.dex
Files) automatisch läuft, muss sich der Android Einsteiger darüber kaum Gedanken machen.
Wir werden für unsere Entwicklungen das ADT Bundle verwenden, welches bereits alle Entwicklungsrelevanten Elemente vereint und unter http://developer.android.com/sdk/index.html kostenfrei heruntergeladen
werden kann.
Diese Umgebung erlaubt es uns mit Hilfe der freien Java basierten Entwicklungsumgebung Eclipse™ den
Code zu erzeugen und zu kompilieren, diesen an das Android SDK zum Crosskompilieren weiterzureichen
und mit Hilfe eines Geräteemulators (AVD – Android Virtual Device) zu emulieren. Es ist allerdings auch
möglich, ein Android Gerät per USB an den Rechner zu stecken und die Tests direkt am realen Hardwaregerät durchzuführen. Sowohl beim virtuellen, als auch beim realen Gerät kann Eclipse als Debugger eingesetzt
werden.
4
Installation der Entwicklungsumgebung
Legen Sie ein beliebiges Verzeichnis in Ihrem Entwicklungsrechner an (bspw. C:\Developmentt\Android).
Gehen sie anschließend zu: http://developer.android.com/sdk/index.html und laden Sie sich das ADT Bundle
herunter:
Anmerkung: Sie können das SDK auch getrennt herunterladen und die entsprechenden notwendigen Plugins
in Ihre bestehende Eclipse Installation integrieren – nachdem Eclipse jedoch wenig Platz wegnimmt und
einfach zu installieren ist, empfehle ich für den Anfang das Bundle.
Entpacken Sie nun das Zip File in das neu erstellte Verzeichnis: C:\Development\Android\adt-bundlewindows
Nun müssen Sie einen Workspace erstellen (bspw. Erstellen unter: C:\Development\Android\Workspace).
Unter dem Eclipse Unterordner Ihres ADT Bundles finden Sie nun die ausführbare Eclipse Datei (eclipSeite 3
Android Umgebung einrichten
se.exe). Starten Sie diese und wählen Sie im Folgedialog Ihren Workspace aus. Das war’s auch schon. Sie
haben Ihre Umgebung installiert und gestartet.
Anmerkung: Wenn es trotzdem mal Probleme gibt sei Ihnen gesagt – es gibt fast kein Problem, welches nicht
irgendwo auf der Welt schon mal aufgetreten ist und nicht von irgendjemand mal gefixed wurde. Meistens
finden sich die Lösungen als Blog- oder Foreneintrag im Netz. Was mir bspw. am Anfang passiert ist war,
dass der Dalvik Debug Monitor Server (DDMS) nicht starten wollte. Nach kurzer Suche im Netz fand ich die
Lösung – die adb.exe (Android Debug Bridge) musste per Task Manager gestoppt werden und schon lief die
Sache wieder. Also – nie die Hoffnung verlieren!
5
Grundgedanken
Bevor wir loslegen, noch ein paar Grundgedanken zum Gesamtkonzept Android. Wie ein Android Gerät
aussieht, das wissen wir. Es gibt dahinter eine gewisse Hierarchie, welche auch beim Programmieren beachtet werden muss:
Ebene:
Gerät / Android
Applikation
Activity
View
Bedeutung:
Das ist die grundlegendste Ebene des Android Systems. Hier liegt
die Kontrolle sämtlicher Abläufe. Bspw. sollte ein Telefonanruf alle
Aktivitäten in Pause versetzen, damit man den Anruf entgegen
nehmen kann.
Das ist die Sammlung aller Aktivitäten unseres Programms.
Bei einer Desktopprogrammierung würden dies die Dialoge sein.
Die Applikation startet die MainActivity, welche eine Art „Anker“
für das gesamte Programm darstellt.
Die einzelnen Elemente innerhalb der Activities sind Views – also
Buttons, Textelemente, Grafiken usw. Angeordnet werden die
Views innerhalb von Layouts.
Das eigentliche Problem bei der mobilen Programmierung ist jedoch die Tatsache, dass im Regelfall die
Bildschirme von den Applikationen voll ausgefüllt sind, die Bildschirmgröße und –ausrichtung nicht genormt ist. Ein Tablett ist größer als ein Handy und wird darüber hinaus im Regelfall in Querausrichtung genutzt – wobei dies nicht so sein muss. Diese Flexibilität im Layout Design ist für viele Neueinsteiger mit die
größte Hürde!
6
HelloWorld – die erste App
Für Ihre erste App starten Sie Eclipse,
wie oben beschrieben. Legen Sie ein
Sie neues Android Projekt an und
folgen dem Wizzard.
Die Folgedialoge erwarten die Eingabe von Basisinformationen für Ihr Projekt. Hierbei werden neben dem
Projekt- und Applikationsnamen auch
ein Packagename vorgeschlagen. Da
empfohlen wird pro Projekt auch nur
eine App zu schreiben, sollten Sie hier
von den Namenskonventionen auch
einheitlich sein.
Weiterhin wird noch das globale Designthema angegeben (hier Holo Light
with Dark Action Bar), welches die
default - Farbgebung bestimmt. Wichtig ist nun noch die Einstellung der
Seite 4
Android Umgebung einrichten
SDK Versionen:
Minimum Required SDK: Das ist die Minimalanforderung an das Gerät. Also müssen die genutzten Libraries dieser Version entsprechen, oder darunter liegen. Wenn Sie eine Funktionalität nutzen möchten welche
ein höheres API Level aufweisen, wird Eclipse einen Fehler melden. Es gibt allerdings Möglichkeiten dies
zu umgehen, indem sogenannte „Support Libraries“ explizit in die Applikation eingebunden werden.
Target SDK: Dies ist das API Level, mit dem getestet wird. Der Emulator sollte somit diesen Level aufweisen.
Compile With: Hier wird das API Level eingestellt, mit dem Kompiliert werden soll. Das ist üblicherweise
die aktuellste API Version. Hintergrund ist, dass Android die Abwärtskompatibilität sicherstellt.
Die nächsten Dialoge kümmern sich um allgemeine Projektkonfigurationen und um den Start Icon. Wir übernehmen zu
diesem Zeitpunkt die Standardeinstellungen. Nun kommt die
Auswahl der Main Activity. Wir wählen hier eine leere Activity aus.
Der letzte Dialog erwartet von uns die Vorgabe eines Namens für die Activity. Wir können hier für die erste
Übung ebenfalls die Standards übernehmen,
oder einfach nur „HelloWorld“ eingeben. Zu
beachten ist, dass sowohl die Activty, als auch
das Layout einen eigenen Namen erhält.
Dies werden wir bei der Analyse der erzeugten
Files nochmal sehen.
Die meisten dieser Einstellungen landen im sogenannten Manifest File (AndroidManifest.xml), wo sie später noch geändert werden können. Dieses File wird in einem späteren Kapitel nochmal kurz angesprochen.
Seite 5
Android Umgebung einrichten
7
Testen der Software
Wir testen die Software vorerst nur auf dem Emulator. Sobald wir „sinnvolle“ Programme schreiben,
werden wir dies auch auf einem realen Gerät ausprobieren. Die Anleitung, wie das geht finden Sie
im Dokument „AnPr_Android_Course_1_3_Task“. Bevor wir aber anfangen, müssen wir uns ein
virtuelles Device konfigurieren auf dem wir die App aufspielen können. Hierzu klickt man auf das
AVD Icon (siehe rechts) und startet den AVD Dialog. Mit
einem Klick auf „New“ wird ein neues AVD erzeugt.
In dem sich öffnenden Dialog werden folgende Einstellungen vorgenommen:
AVD Name: Unter diesem Namen kann zu einem späteren
Zeitpunkt die Konfiguration wieder neu gestartet werden.
Device: Hier finden wir diverse, vorkonfigurierte Devices.
Je nach SDK Version kann dies variieren.
Target: Dies ist das API Level, welches das Testdevice
haben soll.
Front/Back Camera: Wenn die App eine Kamerafunktion
benötigt, kann sie hier eingestellt werden. Ansonsten wird
empfohlen, darauf zu verzichten.
Memory Options: Wie viel RAM Speicher soll das Device aufweisen.
Internal Storage: Wie viel interner persistenter Speicher
soll vorhanden sein.
SD Card: Soll eine SD Karte simuliert werden und wenn
ja, wie groß soll sie sein.
Damit sind alle notwendigen Einstellungen gemacht. Probieren Sie ruhig einige Varianten aus. Vor allem die
verschiedenen Bildschirmgrößen sind wichtig zu testen. Anschließend können Sie das von Ihnen erstellte
AVD auswählen und mit dem „Start“ Button starten. Wenn das System davon ausgeht, dass es sinnvoll ist
die Ausgabe für die Emulation zu skalieren, wird noch ein weiterer Dialog aufgehen, bei dem die Skalierungsoptionen empfohlen werden.
Nun heißt es warten! Nachdem ein voll funktionsfähiges Device emuliert werden muss, kann dies für alle
Initialisierungsmaßnahmen schon mal ein paar Minuten dauern. Erst wenn der Starbildschirm eines Android
Devices (also mit Menü und allem Drum und Dran) erscheint, ist die Startprozedur abgeschlossen. Das Device kann verwendet werden.
Um die App nun auf das Device zu laden, klicken
Sie mit der rechten Maustaste auf den Rootordner
Ihres Projektes („MyFirstApp“) und wählen „Run
As -> Android Application“ aus:
Damit wird die App auf dem Device installiert und gestartet.
Nun wird eventuell noch gefragt, ob Logcat aktiviert werden soll. Dieses dient dazu Device Meldungen auf
einer Konsole auszugeben:
Seite 6
Android Umgebung einrichten
Es wird empfohlen dies auszuwählen. Es können damit später auch Logmeldungen individuell erzeugt werden, um den Entwicklungsprozess zu unterstützen. Wir werden mit Logcat später arbeiten. Wer vorher sich
schon schlau machen möchte wird unter folgendem Link fündig:
http://developer.android.com/reference/android/util/Log.html
Nun sollten Sie im AVD ein App – Fenster sehen, bei dem in der Mitte „HelloWorld“ steht.
8
Die angelegte Struktur
Wie Sie sehen, hat Eclipse eine komplette, lauffähige Struktur angelegt, welche alles Wesentliche einer App
enthält:
Im Folgenden werden wir uns nun diese Struktur etwas genauer ansehen, um die Bedeutung dieser einzelnen
Ordner und Files zu verstehen und später diese auch sinnvoll anpassen zu können.
8.1 Die Main Activity
8.1.1 Die Java Klassen
Im Ordner src finden wir unser Package und dort die erzeugte Java Klasse unserer Main Activity. Hier liegt
die gesamte dynamische Funktionalität unserer Activities. Da wir nur eine Activity haben, existiert hier auch
nur ein *.java File. Wenn Sie nun weitere Activities benötigen, werden die entsprechenden Files auch hier
abgelegt. Auch Hilfsklassen, welche wir für unsere Apps schreiben, werden sich hier befinden.
8.1.2 Die Layout Files
Im Ordner layout liegt das File, welches für die statischen Informationen – vor allem das Layout – zuständig
ist. In unserem Fall ist dies nur das activity_main.xml File. Sämtliche Elemente, welche beim Start unserer
App angezeigt werden sollen, sind hier vermerkt. Dieses File kann direkt im XML-Format, aber auch über
Seite 7
Android Umgebung einrichten
einen WYSIWYG (What You See Is What You Get) Dialog angepasst werden, wobei letzteres nur zur
„Ideenfindung“ und zu einer ersten Kontrolle unserer XML Eingaben dient – die endgültige Version sollte
also immer direkt als XML angepasst werden, da es mitunter schwierig wird, die einzelnen Elemente per
Mauszeiger zu editieren.
8.2 Die Ressourcen
Neben dem Layout File wie es oben beschrieben wurde, gibt es noch viele weitere Ressourcen welche in
einer App verwendet werden. Wir konzentrieren uns im ersten Schritt nur um die, welche beim Anlegen
eines Projektes entstanden sind. Alle weiteren werden später folgen. Grundsätzlich liegen aber alle Ressourcen im Ordner res.
8.2.1 Grafikdateien
Grafiken werden als „drawable“ Ressources bezeichnet und liegen im Unterordner drawable-hdpi, drawable-ldpi, drawable-mdpi und drawable-xhdpi. In allen vier Unterordnern befinden sich die gleichen
(Grafik-)Dateien – wobei man bei näherer Betrachtung erkennt, dass die Grafiken unterschiedliche Auflösungen haben. Dies liegt daran, dass die Ressourcen für verschiedene Bildschirmkategorien vorgehalten
werden.
Im Wesentlichen kennt Android derzeit 4 „Density“ Klassen:
Klasse:
Eigenschaft:
ldpi (low quality)
Geringe Qualität und Auflösung, ca. 120 dpi
mdpi (medium quality) -> Referenzmaß
Mittlere Qualität und Auflösung, ca. 160 dpi
hdpi (high quality)
Hohe Qualität und Auflösung, ca. 240 dpi
xhdpi (extra high quality)
Sehr hohe Qualität und Auflösung, ca. 320 dpi
Für sämtliche Größenangaben in den Layout XML Files wird empfohlen, sogenannte Density Independent
Pixel zu verwenden. Diese werden als „dp“ oder manchmal auch als „dip“ abgekürzt. Folgende Rechenformel zur Berechnung der tatsächlich genutzten Pixel ist zu verwenden:
px = dp * (dpi / 160)
Daraus erkennt man auch, dass ein dp bei einem mdpi Bildschirm genau ein Pixel ist. Ein dp ist somit ca.
0,16mm. Ein Element mit 20 dp Breite wird bei einem xhdpi Display mit 300 dpi, also mit 20 * (300/160) =
37 Pixel angezeigt.
Um beim Skalieren Artefakte zu vermeiden, werden Grafiken für Android
Apps in den vier verschiedenen Bildschirmklassen zur Verfügung gestellt.
Jedes „drawable“ Objekt (also Grafiken) wird redundant in den vier Unterordnern abgelegt. Ein Bild, welches in xhdpi Auflösung 96 Pixel aufweist, in hdpi
72 Pixel, in mdpi 48 Pixel und in ldpi 36 Pixel.
Die minimale Größe von interaktiven Elementen sollte mindestens 48 dp
sein!
8.2.2 Layout Informationen
Im Ordner layout sind für alle Activities die Layout Informationen im XML Format abgelegt. Es können
aber auch für andere Elemente (bspw. für dynamisch erzeugte Teilkomponenten) hier die Layoutdaten abgelegt werden. Weiterhin ist es möglich, verschiedene Layoutalternativen einzutragen, so dass je nach Device
das richtige Layout verwendet werden kann. Dies beginnt schon damit, dass für Landscape (also Querformat) und Portrait (also Hochkantformat) die unterschiedlichen Angaben abgelegt werden können – bis hin zu
verschiedenen Bildschirmkategorien.
8.2.3 Allgemeine Werte
Da Android von vorneherein mehrsprachig ausgelegt ist, sollten sämtliche Textinformationen in Stringdateien (strings.xml) Ausgelagert werden. Dieses File befindet sich unter values. Hier werden alle angezeigten
Textwerte eingetragen und mit einem individuellen Namen versehen. Mehrsprachigkeit wird dadurch erSeite 8
Android Umgebung einrichten
langt, dass für die verschiedenen Sprachen ein eigener values Ordner angelegt wird und die entsprechenden
Stringnamen dort ebenfalls eingetragen werden – aber eben mit den Werten in anderer Sprache.
8.3 AndroidManifest.xml
Das gewichtigste Konfigurationsfile ist das AndroidManifest.xml. Hier werden alle Informationen abgelegt,
welche für das System zum Betrieb des Projektes benötigt. Hier stehen bspw. die API Level, die Activities
werden registriert und ähnliche grundlegenden Funktionalitäten eingestellt.
9
Ein kurzer Blick auf die wichtigsten XML Dateien
9.1 activity_main.xml
Hier eine beispielhafte Layout Datei mit einem View Element.
<RelativeLayout xmlns:android=
"http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/hello_world"
/>
</RelativeLayout>
Hier wird das grundlegende Layout
festgelegt (hier Relative Layout).
Danach folgen die Höhen- und Breitenangaben.
Info rein für die Entwicklungsumgebung.
Hier wird ein Text angezeigt.
Auch hier gibt es Höhen- und Breitenangaben.
Die Ausrichtung kann horizontal und
vertikal festgelegt werden.
Der Text wird aus der strings.xml
Datei entnommen.
9.2 strings.xml
In den strings.xml finden sich alle Textelemente wieder.
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">
MyFirstApp</string>
<string name="hello_world">Hello
world!</string>
<string name="menu_settings">
Settings</string>
</resources>
Allgemeine xml Information.
Indikation, dass Ressourceninformationen definiert werden.
Einzelne String Elemente mit einem
eindeutigen Namen und dem eigentlichen Stringwert.
Um nun Mehrsprachigkeit zu unterstützen, muss für jede Sprache ein eigener
Ordner unter dem values Ordner angelegt werden. Die einzelnen Spracherweiterungen werden nach dem Bindestrich angehängt. Für Deutsch wird ein „de“ ergänzt. Weitere Kürzel können im Netz gefunden werden.
Innerhalb der entsprechenden Unterordner befindet sich jeweils ein weiteres
strings.xml File, in dem sämtliche Stringelemente eingetragen sind, welche für
die verschiedenen Sprachen abweichen sollen:
Seite 9
Android Umgebung einrichten
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">
Meine erste App</string>
<string name="hello_world">
Hallo Welt!</string>
</resources>
In der deutschen strings.xml wurde der String
mit dem Namen „hello world“ mit dem Wert
„Hallo Welt!“ belegt. Dadurch wird bei einem
Gerät mit deutscher Spracheinstellung bei allen
„hello world“ Strings dieser „Hallo Welt!“ Wert
anstatt „hello world“ verwendet.
Die Strings werden entweder direkt in den XML Files referenziert (siehe activity_main.xml), oder sie können via Java Code instanziiert werden:
String myString =
getResources().getString(R.string.hello_world);
9.3 AndroidManifest.xml
Wie bereits erwähnt wurde, ist das AndroidManifest.xml die grundlegendste Konfigurationsebene für unsere App. Hier das Beispielfile einer einfachen Applikation:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.myfirstapp"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="9"
android:targetSdkVersion="16" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity android:name="com.example.myfirstapp.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
</application>
</manifest>
Vom Aufbau her ist das File selbsterklärend. Grundsätzlich gilt, dass alle projektweiten Einstellungen hier
vorgenommen werden. Im Vordergrund stehen hier die Informationen, welche das Android System benötigt,
um die Applikation ausführen zu können. Hierzu zählt auch die Registrierung aller Activities und die „Intent
Filter“. Intents sind im Wesentlichen dafür zuständig, die Kommunikation innerhalb des Systems abzuwickeln und somit auch den Start einer Applikation.
9.4 ids.xml
Unter dem values Ordner können auch selbst definierte XML Files abgelegt werden. Ein häufig anzutreffendes File ist das ids.xml File. Zur Erklärung der Bedeutung dieses Files muss man verstehen, dass jedes Layout Element in Android eine eigene ID besitzen sollte. Da dies standardmäßig vom Eclipse Wizzard nicht
gewährleistet ist, müssen diese IDs vom Programmierer eingetragen werden. Eine ID für das TextView Element von Oben würde wie folgt aussehen:
Seite 10
Android Umgebung einrichten
<TextView
android:id="@+id/txtView_myMainText"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/hello_world" />
Der Syntax sieht vor, dass über @+id eine ID hinzugefügt werden soll, welche den Namen
txtView_myMainText tragen soll. Somit wird beim Kompilliervorgang eine innerhalb der Applikation
eindeutige ID erzeugt, mit deren Hilfe das entsprechende Element eindeutig identifiziert werden und im Java
Code angesprochen werden kann:
TextView myTxt = (TextView) findViewById(R.id.txtView_myMainText);
Die Details dieses Aufrufs wird zu einem späteren Zeitpunkt geklärt.
Nachdem es aber auch die Möglichkeit geben muss, Elemente im Java Code dynamisch zu erzeugen, sollte es auch die Möglichkeit geben, IDs für die spätere Verwendung zu generieren. Hiefür wird ein ids.xml File geschaffen, welches ebenfalls unter
dem Ordner values liegt.
In diesem File werden nun einfach die IDs als Namenwerte eingetragen, wobei das System intern pro ID eine
eindeutige Nummer vergibt:
<?xml version="1.0" encoding="UTF-8"?>
<resources>
<item type="id" name="myDynElement"/>
</resources>
Einem dynamisch erzeugten Element kann nun mit der Methode setId(R.id.myDynElement) diese ID zugeordnet werden.
Seite 11
Android Umgebung einrichten
10 Lizenz
Diese(s) Werk bzw. Inhalt von Maik Aicher (www.codeconcert.de) steht unter einer
Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 3.0 Unported Lizenz.
The Android robot is reproduced or modified from work created and shared by Google and used according to
terms described in the Creative Commons 3.0 Attribution License.
“Eclipse” and the Eclipse Logo are trademarks of Eclipse Foundation, Inc.
"Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of
their respective owners."
11 Haftung
Ich übernehme keinerlei Haftung für die Richtigkeit der hier gemachten Angaben. Sollten Fehler in dem
Dokument enthalten sein, würde ich mich über eine kurze Info unter [email protected] freuen.
Seite 12