Quelltext der Seite Android Training/Building a Simple User Interface/de

<languages/>
[[Datei:Viewgroup.png|thumb|Illustration, wie ViewGroup Objekte Zweige im Layout bilden und View Objekte beinhalten.]]
In dieser Übung erstellst du ein Layout in XML, welches ein Textfeld und ein Button enthält. In der darauffolgenden Übung wird deine App auf einen Button-Klick reagieren und den Inhalt des Textfeldes an eine andere Aktivität senden.

Die grafische Benutzeroberfläche für eine Android App wird mit Hilfe einer Hierarchie aus <code>View</code>- und <code>ViewGroup</code>-Objekten erstellt. <code>View</code> Objekte sind normalerweise UI-Widgets wie Buttons oder Textfelder. <code>ViewGroup</code> Objekte sind nicht sichtbare <code>View</code> Container, welche definieren, wie die darin befindlichen Ansichten angeordnet sind, bspw. anhand eines Rasters oder einer vertikalen Liste.

Android stellt ein XML-Vokabular bereit, welches den Sub-Klassen von <code>View</code> und <code>ViewGroup</code> entspricht, daher kannst du die UI in XML mit Hilfe einer Hierarchie von UI Elementen definieren.

<code>Layouts</code> sind Subklassen von <code>ViewGroup</code>. In dieser Übung arbeitest du mit <code>LinearLayout</code>.

== Ein Lineares Layout erstellen ==
# Öffne in Android Studio die Datei <code>activity_my.xml</code> aus dem Ordner <code>res/layout</code>
#: Die BlankActivity Vorlage, die du beim Erstellen des Projektes ausgewählt hast, enthält die Datei <code>activity_my.xml</code> mit einem RelativeLayout Basis-View und beinhaltet eine <code>TextView</code>.
# Klicke das Verstecken-Icon im Vorschau-Bereich, um diesen zu verbergen.
# In ANdroid Studio siehst du beim Öffnen einer Layout-Datei zuerst den Vorschaubereich. Beim Klicken auf ein Element in dieser Ansicht werden die WYSIWYG Tools im Design-Bereich geöffnet. In dieser Übung wirst du direkt mit dem XML arbeiten.
# Lösche das [http://developer.android.com/reference/android/widget/TextView.html <code><TextView></code>] Element.
# Ändere das [http://developer.android.com/reference/android/widget/RelativeLayout.html <code><RelativeLayout></code>] zu einem [http://developer.android.com/reference/android/widget/LinearLayout.html <code><LinearLayout></code>].
# Füge das [http://developer.android.com/reference/android/widget/LinearLayout.html#attr_android:orientation <code>android:orientation</code>]-Attribut hinzu und setze den Wert auf <code>"horizontal"</code>.
# Entferne das <code>android:padding</code>- und <code>tools:context</code>-Attribut.

Das Ergebnis sieht wie folgt aus:
''res/layout/activity_my.xml''
<syntaxhighlight lang="xml">
<LinearLayout 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"
    android:orientation="horizontal" >
</LinearLayout>
</syntaxhighlight>
<code>LinearLayout</code> ist ein ViewGroup (Sub-Klasse von [http://developer.android.com/reference/android/view/ViewGroup.html <code>ViewGroup</code>]), in welchem untergeordnete Views entweder vertikal oder horizontal angeordnet sind, was durch das Attribut <code>android:orientation</code> spezifiziert wird. Jedes Unterelement eines LinearLayout erscheint auf dem Display in der Reihenfolge, wie es im XML angeordnet ist.

Zwei weitere Attribute, <code>android:layout_width</code> und <code>android:layout_height</code>, sind für alle Views erforderlich, um die Größe fest zu legen.

Weil das <code>LinearLayout</code> die Hauptansicht des Layout ist, sollte des den kompletten, für die App verfügbaren Platz ausfüllen, was durch das Setzen von <code>"match_parent"</code> für die Höhe und Breite erreicht wird. Dieser Wert deklariert, dass die Ansicht ihre Breite oder Höhe entsprechend der Höhe oder Breite der übergeordneten Ansicht expandieren soll.

Für weitere Informationen über die Layout Eigenschaften, siehe den Layout Guide.

== Ein Textfeld hinzufügen ==
Wie mit jedem [http://developer.android.com/reference/android/view/View.html <code>View</code>] Objekt musst du bestimmte XML-Attribute definieren um die Eigenschaften des [http://developer.android.com/reference/android/widget/EditText.html <code>EditText</code>] Objektes zu spezifizieren.

# Definiere innerhalb des <code><LinearLayout></code> Elements, in der <code>activity_my.xml</code> Datei, ein <code><EditText></code> Element mit dem id Attribut und setze es auf @+id/edit_message.
# Definiere für die Attribute <code>layout_width</code> und <code>layout_height</code> den Wert <code>wrap_content</code>.
# Definiere ein <code>hint</code> Attribut als string-Objekt mit dem Namen <code>edit_message</code>.

Das <code><EditText></code> Element sollte wie folgt aussehen:
''res/layout/activity_my.xml''
<syntaxhighlight lang="xml">
<EditText android:id="@+id/edit_message"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:hint="@string/edit_message" />
</syntaxhighlight>
Hier sind die <EditText> Attribute, welche du hinzugefügt hast:

=== [http://developer.android.com/reference/android/view/View.html#attr_android:id <code>android:id</code>] ===
Dieses Attribut stellt eine eindeutige Kennzeichnung für ein View bereit, welches du zum referenzieren des Objektes in deinem App Code verwenden kannst, bspw. um es auszulesen oder zu manipulieren (das wirst du in der nächsten Übung sehen).
Das at-Zeichen (<code>@</code>) ist notwendig, wenn du auf ein Objekt aus dem XML Bezug nimmst. Anschließend folgt der Ressourcen-Typ (<code>id</code> in diesem Fall), ein Bindestrich und dann der Ressourcen-Name (<code>edit_message</code>).
Das Plus-Zeichen (<code>+</code>) vor dem Ressourcen-Typ wird nur dann benötigt, wenn du eine Ressourcen-ID das erste mal definierst. Wenn du deine App kompilierst, verwenden die SDK Tools die ID um eine neue Ressourcen-ID in der <code>gen/R.java</code> Datei deines Projektes zu erstellen, welche auf das EditText Element verweisen. Nachdem die Ressourcen-ID einmal so deklariert wurde, benötigen andere Referenzen zu dieser ID kein Plus-Zeichen mehr. Das Plus-Zeichen wird nur dann benötigt, wenn eine neue Ressourcen-ID spezifiziert wird und wird nicht für konkrete Ressourcen benötigt, bspw. Zeichenketten oder Layouts.

=== [http://developer.android.com/reference/android/view/View.html#attr_android:layout_width <code>android:layout_width</code>] und [http://developer.android.com/reference/android/view/View.html#attr_android:layout_height <code>android:layout_height</code>] ===
Anstelle von festen Größen für die Breite und Höhe, gibt der Wert <code>"wrap_content"</code> an, dass das View so groß wie nötig sein soll um die Inhalte anzuzeigen. Wenn du stattdessen <code>"match_parent"</code> verwendest, wird das <code>EditText</code> Element das komplette Display ausfüllen, weil es die Größe des übergeordneten <code>LinearLayout</code> verwendet. Mehr Informationen findest du im Layouts Guide.

=== [http://developer.android.com/reference/android/widget/TextView.html#attr_android:hint <code>android:hint</code>] ===
Dies ist die Standard-Zeichenkette, welche angezeigt wird, wenn das Textfeld leer ist. Anstelle eines ''hard-coded'' Wertes, der Wert <code>"@string/edit_message"</code> referenziert eine Zeichenketten-Ressource, welche in einer separaten Datei definiert ist. Weil dies eine konkrete Ressource referenziert (nicht wie ein Identifier), benötigt es kein Plus-Zeichen. Allerdings siehst du zuerst einen Kompiler-Fehler, da die Zeichenkette noch nicht definiert ist. Diesen Fehler wirst du im nächsten Abschnitt beheben.

== Eine Zeichenkette (Ressource) hinzufügen ==
Standardmäßig enthält dein Android-Projekt eine Zeichenketten-Ressourcen-Datei unter <code>res/values/strings.xml</code>. Hier fügst du eine neue Zeichenkette mit dem Namen <code>"edit_message"</code> hinzu und setzt ihren Wert auf "Eine Nachricht eingeben."

# Öffne aus dem Ordner <code>res/values</code> die Datei <code>strings.xml</code> in [[Android Studio]]
# Füge eine Zeile für eine Zeichenkette mit dem Namen <code>"edit_message"</code> und dem Wert "Eine Nachricht eingeben." hinzu.
# Füge eine Zeile für eine Zeichenkette mit dem Namen <code>"button_send"</code> und dem Wert "Senden" hinzu.
# Du wirst den Button, der diese Zeichenkette verwendet, im nächsten Abschnitt hinzufügen.
# Entferne die Zeile mit der <code>"hello world"</code> Zeichenkette.

Das Ergebnis für die <code>strings.xml</code> Datei sieht wie folgt aus:

''res/values/strings.xml''
<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">My First App</string>
    <string name="edit_message">Enter a message</string>
    <string name="button_send">Send</string>
    <string name="action_settings">Settings</string>
    <string name="title_activity_main">MainActivity</string>
</resources>
</syntaxhighlight>
Definiere für Text in der Benutzeroberfläche immer eine Zeichenkette als Ressource. Zeichenketten-Ressourcen erlauben es dir, jeden Text der Benutzeroberfläche an einem einzigen Ort zu verwalten, was es einfacher macht, den Text zu finden und zu aktualisieren. Außerdem erlaubt dir das, deine App in verschiedene Sprachen zu lokalisieren, indem alternative Definitionen für jede Zeichenkette bereit gestellt werden.

Für mehr Informationen zur Verwendung von Zeichenketten (als Ressourcen) zur Lokalisierung in andere Sprachen, siehe die "Supporting Different Devices class".

== Ein Button hinzufügen ==
# Bearbeite die Datei <code>activity_my.xml</code> aus dem Ordner <code>res/layout</code> in Android Studio.
# Definiere im <code><LinearLayout></code> Element, direkt nach dem <code><EditText></code> Element, ein [http://developer.android.com/reference/android/widget/Button.html <code><Button></code>] Element.
# Setze für die width und height Attribute des Buttons <code>"wrap_content"</code> als Wert, sodass der Button nur so groß ist, damit der komplette Button-Text angezeigt wird.
# Definiere die Aufschrift des Buttons mit dem [http://developer.android.com/reference/android/widget/TextView.html#attr_android:text <code>android:text</code>] Attribut; setze als Wert die <code>button_send</code> Zeichenketten-Ressource, welche du im vorherigen Abschnitt definiert hast.
Dein <code><LinearLayout></code> sollte wie folgt aussehen:

''res/layout/activity_my.xml''
<syntaxhighlight lang="xml">
<LinearLayout 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"
    android:orientation="horizontal" >
      <EditText android:id="@+id/edit_message"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="@string/edit_message" />
      <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/button_send" />
</LinearLayout>
</syntaxhighlight>
'''Hinweis''': Der Button benötigt kein <code>android:id</code> Attribut, da es im Activity-Code nicht referenziert wird.
[[Datei:edittext_wrap.png|thumb|Die EditText und Button Widgets haben als Breite "wrap_content" gesetzt.]]
Das Layout ist aktuell so entworfen, dass beide Widgets, <code>EditText</code> und <code>Button</code>, nur so breit sind, um ihre Inhalte anzeigen zu können, wie im Bild zu sehen.

Das funktioniert für den Button ausgezeichnet, nicht aber für das Textfeld, da der Nutzer ggf. etwas längeres eingeben wird. Es wäre schön, wenn der ungenutzte Platz für die Breite des Textfeldes verwendet wird. Im <code>LinearLayout</code> kannst du dies mit der weight-Eigenschaft erreichen, unter Verwendung des [http://developer.android.com/reference/android/widget/LinearLayout.LayoutParams.html#weight <code>android:layout_weight</code>]  Attributes.

Der weight-Wert ist eine Zahl, welche festlegt, wie viel verfügbaren Platz jedes View verwenden soll, relativ zu der Menge die andere Views verwenden. Das funktioniert ähnlich wie bei einem Getränke-Rezept: "2 Teile Soda, 1 Teil Sirup" bedeutet, 2/3 vom Getränk ist Soda. Gibst du beispielsweise einem View ein Gewicht von 2 und einem anderen ein Gewicht von 1, ist die Summe 3, sodass das erste View 2/3 vom verfügbaren Platz und das Zweite den Rest verwenden wird. Wenn du ein drittes View mit einem Gewicht von 1 hinzufügst, wird das erste View (mit dem Gewicht 2) nun die Hälfte des verfügbaren Platzes und die verbleibenden anderen beiden Views jeweils ein 1/4 verwenden.

Das Standard-Gewicht von allen Views ist 0, was bedeutet, wenn du einem View einen Wert größer 0 gibst, wird es den kompletten verfügbaren Platz verwenden, nachdem alle Elemente den Platz bekommen haben, den sie mindestens benötigen.

== Das Eingabefeld die Komplette Bildschirmbreite füllen lassen ==
Um den verbleibenden Platz in deinem Layout mit dem <code>EditText</code> Element zu füllen, musst du folgendes tun:

# Weise dem <code>layout_weight</code> Attribut des <code><EditText></code> Elements in der <code>activity_my.xml</code> Datei den Wert <code>1</code> zu.
# Weise außerdem dem <code>layout_width</code> Attribut des <code><EditText></code> Elements den Wert <code>0dp</code> zu.
#: ''res/layout/activity_my.xml''
#: <syntaxhighlight lang="xml">
<EditText
    android:layout_weight="1"
    android:layout_width="0dp"
    ... />
</syntaxhighlight>
Um bei der Verwendung von weight die Effizienz des Layouts zu verbessern, solltest du die Breite von <code>EditText</code> auf 0 setzen (0do). Das Setzen einer Breite von 0 verbessert die Leistungsfähigkeit, weil bei der Verwendung von <code>"wrap_content"</code> als Breite das System die Breite berechnen muss, welche letztlich irrelevant ist, da die Breite erneut in Bezug auf das Gewicht berechnet werden muss, um den verbleibenden Platz auszufüllen.

So sollte deine komplette <code>activity_my.xml</code> Layout-Datei nun aussehen:
''res/layout/activity_my.xml''
<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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"
    android:orientation="horizontal">
    <EditText android:id="@+id/edit_message"
        android:layout_weight="1"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:hint="@string/edit_message" />
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/button_send" />
</LinearLayout>
</syntaxhighlight>

== Starte deine App ==
Das Layout wird von der Standard-<code>Activity</code> Klasse angewendet, welche durch die SDK Tools beim Erstellen des Projektes angelegt wurde. Starte die App um das Ergebnis zu sehen:

# Klicke '''Start''' in der Android Studio Toolbar.
# Oder wechsle in einer Kommandozeile zu dem Stammverzeichnis deines Android Projektes und führe folgende Befehle aus:
#: <code>ant debug</code>
#: <code>adb install bin/MyFirstApp-debug.apk</code>
Fahre mit der nächsten Lektion fort, um zu lernen wie auf einen Klick auf einen Button reagiert, der Inhalt des Textfeldes ausgelesen oder eine andere Activity gestartet werden kann und mehr.

{{TNT|Android Training/Attribution}}