Android Training: Eine einfache Benutzeroberfläche erstellen

Aus Android Wiki
Wechseln zu: Navigation, Suche
Diese Seite ist eine übersetzte Version der Seite Android Training/Building a Simple User Interface und die Übersetzung ist zu 100 % abgeschlossen sowie aktuell.

Sprachen:
Deutsch • ‎English
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 View- und ViewGroup-Objekten erstellt. View Objekte sind normalerweise UI-Widgets wie Buttons oder Textfelder. ViewGroup Objekte sind nicht sichtbare View 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 View und ViewGroup entspricht, daher kannst du die UI in XML mit Hilfe einer Hierarchie von UI Elementen definieren.

Layouts sind Subklassen von ViewGroup. In dieser Übung arbeitest du mit LinearLayout.

Ein Lineares Layout erstellen[Bearbeiten | Quelltext bearbeiten]

  1. Öffne in Android Studio die Datei activity_my.xml aus dem Ordner res/layout
    Die BlankActivity Vorlage, die du beim Erstellen des Projektes ausgewählt hast, enthält die Datei activity_my.xml mit einem RelativeLayout Basis-View und beinhaltet eine TextView.
  2. Klicke das Verstecken-Icon im Vorschau-Bereich, um diesen zu verbergen.
  3. 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.
  4. Lösche das <TextView> Element.
  5. Ändere das <RelativeLayout> zu einem <LinearLayout>.
  6. Füge das android:orientation-Attribut hinzu und setze den Wert auf "horizontal".
  7. Entferne das android:padding- und tools:context-Attribut.

Das Ergebnis sieht wie folgt aus: res/layout/activity_my.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>

LinearLayout ist ein ViewGroup (Sub-Klasse von ViewGroup), in welchem untergeordnete Views entweder vertikal oder horizontal angeordnet sind, was durch das Attribut android:orientation spezifiziert wird. Jedes Unterelement eines LinearLayout erscheint auf dem Display in der Reihenfolge, wie es im XML angeordnet ist.

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

Weil das LinearLayout die Hauptansicht des Layout ist, sollte des den kompletten, für die App verfügbaren Platz ausfüllen, was durch das Setzen von "match_parent" 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[Bearbeiten | Quelltext bearbeiten]

Wie mit jedem View Objekt musst du bestimmte XML-Attribute definieren um die Eigenschaften des EditText Objektes zu spezifizieren.

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

Das <EditText> Element sollte wie folgt aussehen: res/layout/activity_my.xml

<EditText android:id="@+id/edit_message"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:hint="@string/edit_message" />

Hier sind die <EditText> Attribute, welche du hinzugefügt hast:

android:id[Bearbeiten | Quelltext bearbeiten]

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 (@) ist notwendig, wenn du auf ein Objekt aus dem XML Bezug nimmst. Anschließend folgt der Ressourcen-Typ (id in diesem Fall), ein Bindestrich und dann der Ressourcen-Name (edit_message). Das Plus-Zeichen (+) 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 gen/R.java 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.

android:layout_width und android:layout_height[Bearbeiten | Quelltext bearbeiten]

Anstelle von festen Größen für die Breite und Höhe, gibt der Wert "wrap_content" an, dass das View so groß wie nötig sein soll um die Inhalte anzuzeigen. Wenn du stattdessen "match_parent" verwendest, wird das EditText Element das komplette Display ausfüllen, weil es die Größe des übergeordneten LinearLayout verwendet. Mehr Informationen findest du im Layouts Guide.

android:hint[Bearbeiten | Quelltext bearbeiten]

Dies ist die Standard-Zeichenkette, welche angezeigt wird, wenn das Textfeld leer ist. Anstelle eines hard-coded Wertes, der Wert "@string/edit_message" 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[Bearbeiten | Quelltext bearbeiten]

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

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

Das Ergebnis für die strings.xml Datei sieht wie folgt aus:

res/values/strings.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>

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[Bearbeiten | Quelltext bearbeiten]

  1. Bearbeite die Datei activity_my.xml aus dem Ordner res/layout in Android Studio.
  2. Definiere im <LinearLayout> Element, direkt nach dem <EditText> Element, ein <Button> Element.
  3. Setze für die width und height Attribute des Buttons "wrap_content" als Wert, sodass der Button nur so groß ist, damit der komplette Button-Text angezeigt wird.
  4. Definiere die Aufschrift des Buttons mit dem android:text Attribut; setze als Wert die button_send Zeichenketten-Ressource, welche du im vorherigen Abschnitt definiert hast.

Dein <LinearLayout> sollte wie folgt aussehen:

res/layout/activity_my.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>

Hinweis: Der Button benötigt kein android:id Attribut, da es im Activity-Code nicht referenziert wird.

Die EditText und Button Widgets haben als Breite "wrap_content" gesetzt.

Das Layout ist aktuell so entworfen, dass beide Widgets, EditText und Button, 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 LinearLayout kannst du dies mit der weight-Eigenschaft erreichen, unter Verwendung des android:layout_weight 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[Bearbeiten | Quelltext bearbeiten]

Um den verbleibenden Platz in deinem Layout mit dem EditText Element zu füllen, musst du folgendes tun:

  1. Weise dem layout_weight Attribut des <EditText> Elements in der activity_my.xml Datei den Wert 1 zu.
  2. Weise außerdem dem layout_width Attribut des <EditText> Elements den Wert 0dp zu.
    res/layout/activity_my.xml
    <EditText
        android:layout_weight="1"
        android:layout_width="0dp"
        ... />
    

Um bei der Verwendung von weight die Effizienz des Layouts zu verbessern, solltest du die Breite von EditText auf 0 setzen (0do). Das Setzen einer Breite von 0 verbessert die Leistungsfähigkeit, weil bei der Verwendung von "wrap_content" 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 activity_my.xml Layout-Datei nun aussehen: res/layout/activity_my.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>

Starte deine App[Bearbeiten | Quelltext bearbeiten]

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

  1. Klicke Start in der Android Studio Toolbar.
  2. Oder wechsle in einer Kommandozeile zu dem Stammverzeichnis deines Android Projektes und führe folgende Befehle aus:
    ant debug
    adb install bin/MyFirstApp-debug.apk

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.