Android Training/Building a Simple User Interface/de: Unterschied zwischen den Versionen

Aus Android Wiki
(Die Seite wurde neu angelegt: „# Definiere innerhalb des <code><LinearLayout></code> Elements, in der <code>activity_my.xml</code> Datei, ein <code><EditText></code> Element mit dem id Attri…“)
(Die Seite wurde neu angelegt: „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 Activit…“)
 
(29 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
<languages />
<languages/>
[[Datei:Viewgroup.png|thumb|Illustration, wie ViewGroup Objekte Zweige im Layout bilden und View Objekte beinhalten.]]
[[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.
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.
Zeile 55: Zeile 55:


=== [http://developer.android.com/reference/android/view/View.html#attr_android:id <code>android:id</code>] ===
=== [http://developer.android.com/reference/android/view/View.html#attr_android:id <code>android:id</code>] ===
This provides a unique identifier for the view, which you can use to reference the object from your app code, such as to read and manipulate the object (you'll see this in the next lesson).
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).
The at sign (<code>@</code>) is required when you're referring to any resource object from XML. It is followed by the resource type (<code>id</code> in this case), a slash, then the resource name (<code>edit_message</code>).
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>).
The plus sign (<code>+</code>) before the resource type is needed only when you're defining a resource ID for the first time. When you compile the app, the SDK tools use the ID name to create a new resource ID in your project's <code>gen/R.java</code> file that refers to the EditText element. With the resource ID declared once this way, other references to the ID do not need the plus sign. Using the plus sign is necessary only when specifying a new resource ID and not needed for concrete resources such as strings or layouts. See the sidebox for more information about resource objects.
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>] and [http://developer.android.com/reference/android/view/View.html#attr_android:layout_height <code>android:layout_height</code>] ===
=== [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>] ===
Instead of using specific sizes for the width and height, the <code>"wrap_content"</code> value specifies that the view should be only as big as needed to fit the contents of the view. If you were to instead use <code>"match_parent"</code>, then the <code>EditText</code> element would fill the screen, because it would match the size of the parent <code>LinearLayout</code>. For more information, see the Layouts guide.
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>] ===
=== [http://developer.android.com/reference/android/widget/TextView.html#attr_android:hint <code>android:hint</code>] ===
This is a default string to display when the text field is empty. Instead of using a hard-coded string as the value, the <code>"@string/edit_message"</code> value refers to a string resource defined in a separate file. Because this refers to a concrete resource (not just an identifier), it does not need the plus sign. However, because you haven't defined the string resource yet, you’ll see a compiler error at first. You'll fix this in the next section by defining the string.
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.


== Add String Resources ==
== Eine Zeichenkette (Ressource) hinzufügen ==
By default, your Android project includes a string resource file at <code>res/values/strings.xml</code>. Here, you'll add a new string named <code>"edit_message"</code> and set the value to "Enter a message."
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."


# In [[Android Studio]], from the <code>res/values</code> directory, open <code>strings.xml</code>.
# Öffne aus dem Ordner <code>res/values</code> die Datei <code>strings.xml</code> in [[Android Studio]]
# Add a line for a string named <code>"edit_message"</code> with the value, "Enter a message".
# Füge eine Zeile für eine Zeichenkette mit dem Namen <code>"edit_message"</code> und dem Wert "Eine Nachricht eingeben." hinzu.
# Add a line for a string named <code>"button_send"</code> with the value, "Send".
# Füge eine Zeile für eine Zeichenkette mit dem Namen <code>"button_send"</code> und dem Wert "Senden" hinzu.
# You'll create the button that uses this string in the next section.
# Du wirst den Button, der diese Zeichenkette verwendet, im nächsten Abschnitt hinzufügen.
# Remove the line for the <code>"hello world"</code> string.
# Entferne die Zeile mit der <code>"hello world"</code> Zeichenkette.


The result for <code>strings.xml</code> looks like this:
Das Ergebnis für die <code>strings.xml</code> Datei sieht wie folgt aus:


''res/values/strings.xml''
''res/values/strings.xml''
Zeile 87: Zeile 87:
</resources>
</resources>
</syntaxhighlight>
</syntaxhighlight>
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.
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.


For more information about using string resources to localize your app for other languages, see the Supporting Different Devices class.
Für mehr Informationen zur Verwendung von Zeichenketten (als Ressourcen) zur Lokalisierung in andere Sprachen, siehe die "Supporting Different Devices class".


== Add a Button ==
== Ein Button hinzufügen ==
# In Android Studio, from the <code>res/layout</code> directory, edit the <code>activity_my.xml</code> file.
# Bearbeite die Datei <code>activity_my.xml</code> aus dem Ordner <code>res/layout</code> in Android Studio.
# Within the <code><LinearLayout></code> element, define a [http://developer.android.com/reference/android/widget/Button.html <code><Button></code>] element immediately following the <code><EditText></code> element.
# 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.
# Set the button's width and height attributes to <code>"wrap_content"</code> so the button is only as big as necessary to fit the button's text label.
# 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.
# Define the button's text label with the [http://developer.android.com/reference/android/widget/TextView.html#attr_android:text <code>android:text</code>] attribute; set its value to the <code>button_send</code> string resource you defined in the previous section.
# 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.
Your <code><LinearLayout></code> should look like this:
Dein <code><LinearLayout></code> sollte wie folgt aussehen:


''res/layout/activity_my.xml''
''res/layout/activity_my.xml''
Zeile 115: Zeile 115:
</LinearLayout>
</LinearLayout>
</syntaxhighlight>
</syntaxhighlight>
'''Note''': This button doesn't need the <code>android:id</code> attribute, because it won't be referenced from the activity code.
'''Hinweis''': Der Button benötigt kein <code>android:id</code> Attribut, da es im Activity-Code nicht referenziert wird.
[[Datei:edittext_wrap.png|thumb|The EditText and Button widgets have their widths set to "wrap_content".]]
[[Datei:edittext_wrap.png|thumb|Die EditText und Button Widgets haben als Breite "wrap_content" gesetzt.]]
The layout is currently designed so that both the <code>EditText</code> and <code>Button</code> widgets are only as big as necessary to fit their content, as shown in the picture.
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.


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 <code>LinearLayout</code> with the weight property, which you can specify using the [http://developer.android.com/reference/android/widget/LinearLayout.LayoutParams.html#weight <code>android:layout_weight</code>] attribute.
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.


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.
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.


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.
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.


== Make the Input Box Fill in the Screen Width ==
== Das Eingabefeld die Komplette Bildschirmbreite füllen lassen ==
To fill the remaining space in your layout with the <code>EditText</code> element, do the following:
Um den verbleibenden Platz in deinem Layout mit dem <code>EditText</code> Element zu füllen, musst du folgendes tun:


# In the <code>activity_my.xml</code> file, assign the <code><EditText></code> element's <code>layout_weight</code> attribute a value of <code>1</code>.
# 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.
# Also, assign <code><EditText></code> element's <code>layout_width</code> attribute a value of <code>0dp</code>.
# 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''
#: ''res/layout/activity_my.xml''
#: <syntaxhighlight lang="xml">
#: <syntaxhighlight lang="xml">
Zeile 137: Zeile 137:
     ... />
     ... />
</syntaxhighlight>
</syntaxhighlight>
To improve the layout efficiency when you specify the weight, you should change the width of the <code>EditText</code> to be zero (0dp). Setting the width to zero improves layout performance because using <code>"wrap_content"</code> 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.
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.


Here’s how your complete activity_my.xmllayout file should now look:
So sollte deine komplette <code>activity_my.xml</code> Layout-Datei nun aussehen:
''res/layout/activity_my.xml''
''res/layout/activity_my.xml''
<syntaxhighlight lang="xml">
<syntaxhighlight lang="xml">
Zeile 160: Zeile 160:
</syntaxhighlight>
</syntaxhighlight>


== Run Your App ==
== Starte deine App ==
This layout is applied by the default <code>Activity</code> class that the SDK tools generated when you created the project. Run the app to see the results:
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:


# In Android Studio, from the toolbar, click Run  .
# Klicke '''Start''' in der Android Studio Toolbar.
# Or from a command line, change directories to the root of your Android project and execute:
# Oder wechsle in einer Kommandozeile zu dem Stammverzeichnis deines Android Projektes und führe folgende Befehle aus:
#: <code>ant debug</code>
#: <code>ant debug</code>
#: <code>adb install bin/MyFirstApp-debug.apk</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.


Continue to the next lesson to learn how to respond to button presses, read content from the text field, start another activity, and more.
{{TNT|Android Training/Attribution}}
 
{{Android Training/ Vorlage:Attribution}}

Aktuelle Version vom 18. Dezember 2015, 18:25 Uhr

Sprachen:
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

  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

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

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."

  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

  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

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

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.