Android Training: Eine einfache Benutzeroberfläche erstellen
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
- Öffne in Android Studio die Datei
activity_my.xml
aus dem Ordnerres/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 eineTextView
.
- Die BlankActivity Vorlage, die du beim Erstellen des Projektes ausgewählt hast, enthält die Datei
- 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
<TextView>
Element. - Ändere das
<RelativeLayout>
zu einem<LinearLayout>
. - Füge das
android:orientation
-Attribut hinzu und setze den Wert auf"horizontal"
. - Entferne das
android:padding
- undtools: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
Wie mit jedem View
Objekt musst du bestimmte XML-Attribute definieren um die Eigenschaften des EditText
Objektes zu spezifizieren.
- Definiere innerhalb des
<LinearLayout>
Elements, in deractivity_my.xml
Datei, ein<EditText>
Element mit dem id Attribut und setze es auf @+id/edit_message. - Definiere für die Attribute
layout_width
undlayout_height
den Wertwrap_content
. - Definiere ein
hint
Attribut als string-Objekt mit dem Namenedit_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
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
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
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
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."
- In Android Studio, from the
res/values
directory, openstrings.xml
. - Add a line for a string named
"edit_message"
with the value, "Enter a message". - Add a line for a string named
"button_send"
with the value, "Send". - You'll create the button that uses this string in the next section.
- Remove the line for the
"hello world"
string.
The result for strings.xml
looks like this:
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>
For text in the user interface, always specify each string as a resource. String resources allow you to manage all UI text in a single location, which makes the text easier to find and update. Externalizing the strings also allows you to localize your app to different languages by providing alternative definitions for each string resource.
For more information about using string resources to localize your app for other languages, see the Supporting Different Devices class.
Add a Button
- In Android Studio, from the
res/layout
directory, edit theactivity_my.xml
file. - Within the
<LinearLayout>
element, define a<Button>
element immediately following the<EditText>
element. - Set the button's width and height attributes to
"wrap_content"
so the button is only as big as necessary to fit the button's text label. - Define the button's text label with the
android:text
attribute; set its value to thebutton_send
string resource you defined in the previous section.
Your <LinearLayout>
should look like this:
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>
Note: This button doesn't need the android:id
attribute, because it won't be referenced from the activity code.
The layout is currently designed so that both the EditText
and Button
widgets are only as big as necessary to fit their content, as shown in the picture.
This works fine for the button, but not as well for the text field, because the user might type something longer. It would be nice to fill the unused screen width with the text field. You can do this inside a LinearLayout
with the weight property, which you can specify using the android:layout_weight
attribute.
The weight value is a number that specifies the amount of remaining space each view should consume, relative to the amount consumed by sibling views. This works kind of like the amount of ingredients in a drink recipe: "2 parts soda, 1 part syrup" means two-thirds of the drink is soda. For example, if you give one view a weight of 2 and another one a weight of 1, the sum is 3, so the first view fills 2/3 of the remaining space and the second view fills the rest. If you add a third view and give it a weight of 1, then the first view (with weight of 2) now gets 1/2 the remaining space, while the remaining two each get 1/4.
The default weight for all views is 0, so if you specify any weight value greater than 0 to only one view, then that view fills whatever space remains after all views are given the space they require.
Make the Input Box Fill in the Screen Width
To fill the remaining space in your layout with the EditText
element, do the following:
- In the
activity_my.xml
file, assign the<EditText>
element'slayout_weight
attribute a value of1
. - Also, assign
<EditText>
element'slayout_width
attribute a value of0dp
.- res/layout/activity_my.xml
<EditText android:layout_weight="1" android:layout_width="0dp" ... />
To improve the layout efficiency when you specify the weight, you should change the width of the EditText
to be zero (0dp). Setting the width to zero improves layout performance because using "wrap_content"
as the width requires the system to calculate a width that is ultimately irrelevant because the weight value requires another width calculation to fill the remaining space.
Here’s how your complete activity_my.xmllayout file should now look: 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>
Run Your App
This layout is applied by the default Activity
class that the SDK tools generated when you created the project. Run the app to see the results:
- In Android Studio, from the toolbar, click Run .
- Or from a command line, change directories to the root of your Android project and execute:
ant debug
adb install bin/MyFirstApp-debug.apk
Continue to the next lesson to learn how to respond to button presses, read content from the text field, start another activity, and more.
<translate> Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.</translate>