Wikizone - Benutzerbeiträge [de]

Android Development - Grundfunktionen Programmieren

2013-02-26T22:07:00Z

79.240.86.226: /* onClick Event für den Send Button */

Baut auf diesem Artikel auf:

[[Android Development - User Interface programmieren]]

Wir haben ein kleines Layout mit einem Textfeld und einem Button. Im Folgenden wollen wir das ganze mit einer zweiten Activity verbinden, die auf die Eingabe reagiert.

== onClick Event für den Send Button ==

activity_main.xml
Attribut hinzufügen:
android:onClick="sendMessage"
Bei Klick auf den Button soll die Methode sendMessage aufgerufen werden. Diese fügen wir in der MainActivity Klasse hinzu. (src/MainActivity.java)
<pre>
/** Called when the user clicks the send button **/
public void sendMessage(View view) {
// Do something
}
</pre>
Dazu muß noch die View Klasse importiert werden.
import android.view.View;
In Eclipse kann man fehlende Klassen einfach mit
Ctrl + Shift + O (PC)
Cmd + Shift + O (Mac)

Wichtig zu wissen ist das die Methode für onClick folgende Eigenschaften hat:
* public
* void als Rückgabewert hat
* Einen View als einzigen parameter hat (dieser enthält das View Objekt, das geklickt wurde)

=== Intent Binding ===
Wir möchten als Reaktion auf den Klick eine zweite Activity starten. Dafür gibt es die Intents. die Intention eines Intent ist es einzelne Komponenten zu verbinden. Am häufigsten werden sie dazu eingesetzt eine weitere Activity zu starten.

Man kann sich eine Intent quasi als Kabel zwischen Komponenten vorstellen. So gehts:

in sendMessage() erzeugen wir einen Intent.
Intent intent = new Intent(this, DisplayMessageActivity.class);
Der Konstruktor hat zwei Parameter, es sind quasi die Anschlüsse des Intent.
* Parameter 1 ist ein Context (Klasse). Quasi der Startpunkt des Intent. Hier können wir this nehmen (die Activity) weil Activity eine Subklasse von Context ist.
* Parameter 2 ist die Klasse der App Komponente, an die der Intent liefern soll. Quasi der Endpunkt des Kabels. hier ist es die Activity die gestartet werden soll.

Die Klasse DisplayMessageActivity.class gibt es noch nicht. Deshalb meckert Eclipse noch (...cannot be resolved...) Das holen wir gleich nach, aber zuerst erweitern wir die Funktion:
<pre>
public void sendMessage(View view) {
Intent intent = new Intent(this, DisplayMessageActivity.class);
EditText editText = (EditText) findViewById(R.id.edit_message);
String message = editText.getText().toString();
intent.putExtra(EXTRA_MESSAGE, message);
}
</pre>

Dazu brauchen wir noch zwei imports:
import android.content.Intent;
import android.widget.EditText;

Mit der putExtra Methode kann der Intent verschiedene Typen von Daten als Key-Value Paare übermitteln. putExtra(key,value) Die Konstante EXTRA_MESSAGE definieren wir gleich.

Mit findViewById können wir das Text-View-Objekt holen und danach die Textnachricht auslesen.

Die Konstante definieren wir in der MainActivity Klasse

public class MainActivity extends Activity {
public final static String EXTRA_MESSAGE = "de.webmynet.firstapp.MESSAGE";
...

Android Development - Grundfunktionen Programmieren

2013-02-26T21:40:27Z

79.240.86.226: Die Seite wurde neu angelegt: „Baut auf diesem Artikel auf: Android Development - User Interface programmieren Wir haben ein kleines Layout mit einem Textfeld und einem Button. Im Folgend…“

Android Development - User Interface programmieren

2013-02-26T21:26:50Z

79.240.86.226: /* Links */

== Links ==
Nächster Schritt: [[Android Development - Grundfunktionen Programmieren]]

http://developer.android.com/guide/topics/ui/declaring-layout.html

== Einleitung ==

Ein grafisches Frontend besteht in Android aus einer Hierarchischen Struktur von View und ViewGroup Objekten. Diese werden in einer XML-Datei angelegt. Man kann aber auch welche dynamisch zur Laufzeit vom Programm erzeugen lassen.

== View und ViewGroups ==

View Objekte sind in der Regel UI widgets wie:
buttons
text fields

ViewGroups sind unsichtbare Container mit denen man eine Gruppe von Objekten Anordnen kann.

Die ganze Layout-Struktur wird in einer XML-Datei definiert. In Eclipse gibt es dafür einen praktischen grafischen Editor.

== Layout Beispiel ==
=== Das Default Beispiel ===
Wenn man in Eclipse die Default Anwendung erstellt und Blank Activity gewählt hat erhält man so etwas:

<pre>
<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>
</pre>

Wir haben also ein Relatives Layout, das sich über die ganze Fläche des Screens erstreckt und ein TextView Objekt enthält. Dieses wird zentriert und enthält einen String mit dem Bezeichner hello_world (also nicht den String selbst sondern einen Verweis darauf.)

Ändern wir es mal ab wie es das Google Tutorial vorsieht:

<pre>
<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"
tools:context=".MainActivity" >
</LinearLayout>
</pre>

Wir haben das TextView Element gelöscht und die das Element RelativeLayout in ein LinearLayout verändert. LinearLayout ist übrigens eine ViewGroup oder vielmehr eine Unterklasse davon.

Wir haben außerdem das Attribut android:orientation="horizontal" hinzugefügt. Der Name spricht für sich.

=== Elemente hinzufügen ===
Als nächstes fügen wir ein View Objekt hinzu. Nämlich ein Editierbares Textfeld. Das View Objekt dazu sieht so aus:
<EditText />
Für jedes View Objekt muß man einige Attribute definieren. Dann sieht es so aus:
<EditText android:id="@+id/edit_message"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:hint="@string/edit_message"/>

Das Attribut id vergibt einen Namen mit dem man aus der App referenzieren kann. Das at Zeichen wird benötigt, wenn man dabei auf eine Ressource in einer xml-Datei Referenzieren will. Danach kommt die Ressourcen Art (es geht also um eine id und dann ein Slash gefolgt vom Ressourcen Name (edit_message). Das + braucht man nur wenn man ids zum ersten mal nutzt. Es führt dann beim Kompilieren dazu, daß die Ressourcen ID in gen/R.java generiert wird. Auch für konkrete Dinge wie Strings oder Layouts braucht man es nicht.

Die Höhe und Breite werden wieder wie im Linearlayout mit layout_width und layout_height angegeben. Diesmal wollen wir das das Textfeld nur so groß ist, wie es sein muß.

hint ist der Standardwert im Feld. Es ist wieder eine Referenz auf eine String Ressource. Da es ein String ist brauchen wir dieses mal kein Pluszeichen. Es ist kein Problem das wir den gleichen Namen wie für die ID benutzen, weil es sich um einen anderen Typ handelt (ein String statt eine ID). Allerdings meckert Eclipse, daß der String auf den sich die Referenz bezieht nicht existiert. Das müssen wir noch nachholen.

===Eine String Ressource hinzufügen===
Strings sollten immer separat gepflegt, und nicht hartgecoded werden. Standardmäßig sind die Strings in
res/values/strings.xml
zu finden. Wir ergänzen diese und nehmen gleich noch einen Label für einen Button dazu.
<pre>
<?xml version="1.0" encoding="utf-8"?>
<resources>

<string name="app_name">Beat Tools</string>
<string name="menu_settings">Settings</string>
<string name="button_send">Absenden</string>
<string name="edit_message">Gib was ein</string>

</resources>

</pre>

=== Einen Button hinzufügen ===
Das Label für den Button haben wir schon also zurück ins Layout (activity_main.xml).
Beim Tippen hilft einem Eclipse mit Vorschlägen. Man muß also nicht alle Attribute auswendig kennen. Die Hilfe bekommt man mit Steuerung+Leertaste (Mac Apfel+Leertaste).

Das Textfeld ist jetzt links und der Button klebt am Ende. Schöner wäre es wenn das Textfeld den ganzen verfügbaren Platz (exklusive Button) nutzen würde. Dabei hilft das layout_weight Attribut.

Weight steht für den Anteil in einer View Group. Wenn ein Element 1 und eines 3 hat teilen sie sich den Platz im Verhältnis 1:3 auf. Standard Weight ist 0. Wenn ein Element einen höheren Wert bekommt z.B. 1. Nimmt es den ganzen verfügbaren Platz für sich in Anspruch (abzüglich dem Platz den die anderen Elemente sowieso benötigen.

Wir können also dem Textfeld den Wert 1 geben und er nutzt alles aus was er kriegen kann. Zusätzlich geben wir ihme die Breite zero (0dp) - dadurch spart sich das Handy die Berechnung des wrap_content, das ja ohnehin nicht mehr benötigt wird.

<pre>
<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"
tools:context=".MainActivity" >

<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>
</pre>

Android Development - User Interface programmieren

2013-02-26T21:26:28Z

79.240.86.226: /* Links */

== Links ==
Nächster Schritt: [[Android Development - Grundfunktionen]]

http://developer.android.com/guide/topics/ui/declaring-layout.html

== Einleitung ==

Ein grafisches Frontend besteht in Android aus einer Hierarchischen Struktur von View und ViewGroup Objekten. Diese werden in einer XML-Datei angelegt. Man kann aber auch welche dynamisch zur Laufzeit vom Programm erzeugen lassen.

== View und ViewGroups ==

View Objekte sind in der Regel UI widgets wie:
buttons
text fields

ViewGroups sind unsichtbare Container mit denen man eine Gruppe von Objekten Anordnen kann.

Die ganze Layout-Struktur wird in einer XML-Datei definiert. In Eclipse gibt es dafür einen praktischen grafischen Editor.

== Layout Beispiel ==
=== Das Default Beispiel ===
Wenn man in Eclipse die Default Anwendung erstellt und Blank Activity gewählt hat erhält man so etwas:

<pre>
<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>
</pre>

Wir haben also ein Relatives Layout, das sich über die ganze Fläche des Screens erstreckt und ein TextView Objekt enthält. Dieses wird zentriert und enthält einen String mit dem Bezeichner hello_world (also nicht den String selbst sondern einen Verweis darauf.)

Ändern wir es mal ab wie es das Google Tutorial vorsieht:

<pre>
<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"
tools:context=".MainActivity" >
</LinearLayout>
</pre>

Wir haben das TextView Element gelöscht und die das Element RelativeLayout in ein LinearLayout verändert. LinearLayout ist übrigens eine ViewGroup oder vielmehr eine Unterklasse davon.

Wir haben außerdem das Attribut android:orientation="horizontal" hinzugefügt. Der Name spricht für sich.

=== Elemente hinzufügen ===
Als nächstes fügen wir ein View Objekt hinzu. Nämlich ein Editierbares Textfeld. Das View Objekt dazu sieht so aus:
<EditText />
Für jedes View Objekt muß man einige Attribute definieren. Dann sieht es so aus:
<EditText android:id="@+id/edit_message"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:hint="@string/edit_message"/>

Das Attribut id vergibt einen Namen mit dem man aus der App referenzieren kann. Das at Zeichen wird benötigt, wenn man dabei auf eine Ressource in einer xml-Datei Referenzieren will. Danach kommt die Ressourcen Art (es geht also um eine id und dann ein Slash gefolgt vom Ressourcen Name (edit_message). Das + braucht man nur wenn man ids zum ersten mal nutzt. Es führt dann beim Kompilieren dazu, daß die Ressourcen ID in gen/R.java generiert wird. Auch für konkrete Dinge wie Strings oder Layouts braucht man es nicht.

Die Höhe und Breite werden wieder wie im Linearlayout mit layout_width und layout_height angegeben. Diesmal wollen wir das das Textfeld nur so groß ist, wie es sein muß.

hint ist der Standardwert im Feld. Es ist wieder eine Referenz auf eine String Ressource. Da es ein String ist brauchen wir dieses mal kein Pluszeichen. Es ist kein Problem das wir den gleichen Namen wie für die ID benutzen, weil es sich um einen anderen Typ handelt (ein String statt eine ID). Allerdings meckert Eclipse, daß der String auf den sich die Referenz bezieht nicht existiert. Das müssen wir noch nachholen.

===Eine String Ressource hinzufügen===
Strings sollten immer separat gepflegt, und nicht hartgecoded werden. Standardmäßig sind die Strings in
res/values/strings.xml
zu finden. Wir ergänzen diese und nehmen gleich noch einen Label für einen Button dazu.
<pre>
<?xml version="1.0" encoding="utf-8"?>
<resources>

<string name="app_name">Beat Tools</string>
<string name="menu_settings">Settings</string>
<string name="button_send">Absenden</string>
<string name="edit_message">Gib was ein</string>

</resources>

</pre>

=== Einen Button hinzufügen ===
Das Label für den Button haben wir schon also zurück ins Layout (activity_main.xml).
Beim Tippen hilft einem Eclipse mit Vorschlägen. Man muß also nicht alle Attribute auswendig kennen. Die Hilfe bekommt man mit Steuerung+Leertaste (Mac Apfel+Leertaste).

Das Textfeld ist jetzt links und der Button klebt am Ende. Schöner wäre es wenn das Textfeld den ganzen verfügbaren Platz (exklusive Button) nutzen würde. Dabei hilft das layout_weight Attribut.

Weight steht für den Anteil in einer View Group. Wenn ein Element 1 und eines 3 hat teilen sie sich den Platz im Verhältnis 1:3 auf. Standard Weight ist 0. Wenn ein Element einen höheren Wert bekommt z.B. 1. Nimmt es den ganzen verfügbaren Platz für sich in Anspruch (abzüglich dem Platz den die anderen Elemente sowieso benötigen.

Wir können also dem Textfeld den Wert 1 geben und er nutzt alles aus was er kriegen kann. Zusätzlich geben wir ihme die Breite zero (0dp) - dadurch spart sich das Handy die Berechnung des wrap_content, das ja ohnehin nicht mehr benötigt wird.

<pre>
<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"
tools:context=".MainActivity" >

<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>
</pre>

Android Development - User Interface programmieren

2013-02-26T21:21:07Z

79.240.86.226: /* Eine String Ressource hinzufügen */

== Links ==

http://developer.android.com/guide/topics/ui/declaring-layout.html

== Einleitung ==

Ein grafisches Frontend besteht in Android aus einer Hierarchischen Struktur von View und ViewGroup Objekten. Diese werden in einer XML-Datei angelegt. Man kann aber auch welche dynamisch zur Laufzeit vom Programm erzeugen lassen.

== View und ViewGroups ==

View Objekte sind in der Regel UI widgets wie:
buttons
text fields

ViewGroups sind unsichtbare Container mit denen man eine Gruppe von Objekten Anordnen kann.

Die ganze Layout-Struktur wird in einer XML-Datei definiert. In Eclipse gibt es dafür einen praktischen grafischen Editor.

== Layout Beispiel ==
=== Das Default Beispiel ===
Wenn man in Eclipse die Default Anwendung erstellt und Blank Activity gewählt hat erhält man so etwas:

<pre>
<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>
</pre>

Wir haben also ein Relatives Layout, das sich über die ganze Fläche des Screens erstreckt und ein TextView Objekt enthält. Dieses wird zentriert und enthält einen String mit dem Bezeichner hello_world (also nicht den String selbst sondern einen Verweis darauf.)

Ändern wir es mal ab wie es das Google Tutorial vorsieht:

<pre>
<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"
tools:context=".MainActivity" >
</LinearLayout>
</pre>

Wir haben das TextView Element gelöscht und die das Element RelativeLayout in ein LinearLayout verändert. LinearLayout ist übrigens eine ViewGroup oder vielmehr eine Unterklasse davon.

Wir haben außerdem das Attribut android:orientation="horizontal" hinzugefügt. Der Name spricht für sich.

=== Elemente hinzufügen ===
Als nächstes fügen wir ein View Objekt hinzu. Nämlich ein Editierbares Textfeld. Das View Objekt dazu sieht so aus:
<EditText />
Für jedes View Objekt muß man einige Attribute definieren. Dann sieht es so aus:
<EditText android:id="@+id/edit_message"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:hint="@string/edit_message"/>

Das Attribut id vergibt einen Namen mit dem man aus der App referenzieren kann. Das at Zeichen wird benötigt, wenn man dabei auf eine Ressource in einer xml-Datei Referenzieren will. Danach kommt die Ressourcen Art (es geht also um eine id und dann ein Slash gefolgt vom Ressourcen Name (edit_message). Das + braucht man nur wenn man ids zum ersten mal nutzt. Es führt dann beim Kompilieren dazu, daß die Ressourcen ID in gen/R.java generiert wird. Auch für konkrete Dinge wie Strings oder Layouts braucht man es nicht.

Die Höhe und Breite werden wieder wie im Linearlayout mit layout_width und layout_height angegeben. Diesmal wollen wir das das Textfeld nur so groß ist, wie es sein muß.

hint ist der Standardwert im Feld. Es ist wieder eine Referenz auf eine String Ressource. Da es ein String ist brauchen wir dieses mal kein Pluszeichen. Es ist kein Problem das wir den gleichen Namen wie für die ID benutzen, weil es sich um einen anderen Typ handelt (ein String statt eine ID). Allerdings meckert Eclipse, daß der String auf den sich die Referenz bezieht nicht existiert. Das müssen wir noch nachholen.

===Eine String Ressource hinzufügen===
Strings sollten immer separat gepflegt, und nicht hartgecoded werden. Standardmäßig sind die Strings in
res/values/strings.xml
zu finden. Wir ergänzen diese und nehmen gleich noch einen Label für einen Button dazu.
<pre>
<?xml version="1.0" encoding="utf-8"?>
<resources>

<string name="app_name">Beat Tools</string>
<string name="menu_settings">Settings</string>
<string name="button_send">Absenden</string>
<string name="edit_message">Gib was ein</string>

</resources>

</pre>

=== Einen Button hinzufügen ===
Das Label für den Button haben wir schon also zurück ins Layout (activity_main.xml).
Beim Tippen hilft einem Eclipse mit Vorschlägen. Man muß also nicht alle Attribute auswendig kennen. Die Hilfe bekommt man mit Steuerung+Leertaste (Mac Apfel+Leertaste).

Das Textfeld ist jetzt links und der Button klebt am Ende. Schöner wäre es wenn das Textfeld den ganzen verfügbaren Platz (exklusive Button) nutzen würde. Dabei hilft das layout_weight Attribut.

Weight steht für den Anteil in einer View Group. Wenn ein Element 1 und eines 3 hat teilen sie sich den Platz im Verhältnis 1:3 auf. Standard Weight ist 0. Wenn ein Element einen höheren Wert bekommt z.B. 1. Nimmt es den ganzen verfügbaren Platz für sich in Anspruch (abzüglich dem Platz den die anderen Elemente sowieso benötigen.

Wir können also dem Textfeld den Wert 1 geben und er nutzt alles aus was er kriegen kann. Zusätzlich geben wir ihme die Breite zero (0dp) - dadurch spart sich das Handy die Berechnung des wrap_content, das ja ohnehin nicht mehr benötigt wird.

<pre>
<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"
tools:context=".MainActivity" >

<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>
</pre>

Android Development - User Interface programmieren

2013-02-26T20:48:10Z

79.240.86.226: /* Beispiele */

Android Development - User Interface programmieren

2013-02-26T20:22:24Z

79.240.86.226: /* Einleitung */

Android Development - User Interface programmieren

2013-02-26T20:19:43Z

79.240.86.226:

== Links ==

http://developer.android.com/guide/topics/ui/declaring-layout.html

== Einleitung ==

Ein grafisches Frontend besteht in Android aus einer Hierarchischen Struktur von View und ViewGroup Objekten.

== View und ViewGroups ==

View Objekte sind in der Regel UI widgets wie:
buttons
text fields

ViewGroups sind unsichtbare Container mit denen man eine Gruppe von Objekten Anordnen kann.

Die ganze Layout-Struktur wird in einer XML-Datei definiert. In Eclipse gibt es dafür einen praktischen grafischen Editor.

== Beispiele ==
=== Das Default Beispiel ===
Wenn man in Eclipse die Default Anwendung erstellt und Blank Activity gewählt hat erhält man so etwas:

<pre>
<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>
</pre>

Wir haben also ein Relatives Layout, das sich über die ganze Fläche des Screens erstreckt und ein TextView Objekt enthält. Dieses wird zentriert und enthält einen String mit dem Bezeichner hello_world (also nicht den String selbst sondern einen Verweis darauf.)

Ändern wir es mal ab wie es das Google Tutorial vorsieht:

<pre>
<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"
tools:context=".MainActivity" >
</LinearLayout>
</pre>

Wir haben das TextView Element gelöscht und die das Element RelativeLayout in ein LinearLayout verändert. LinearLayout ist übrigens eine ViewGroup oder vielmehr eine Unterklasse davon.

Wir haben außerdem das Attribut android:orientation="horizontal" hinzugefügt.

Android Development - User Interface programmieren

2013-02-26T20:05:00Z

79.240.86.226:

Einleitung

Ein grafisches Frontend besteht in Android aus einer Hierarchischen Struktur von View und ViewGroup Objekten

View Objekte sind in der Regel UI widgets wie:
buttons
text fields

ViewGroups sind unsichtbare Container mit denen man eine Gruppe von Objekten Anordnen kann.

Die ganze Layout-Struktur wird in einer XML-Datei definiert. In Eclipse gibt es dafür einen praktischen grafischen Editor.

Android Development - User Interface programmieren

2013-02-26T20:03:41Z

79.240.86.226: Die Seite wurde neu angelegt: „Einleitung Ein grafisches Frontend besteht in Android aus einer Hierarchischen Struktur von View und ViewGroup Objekten View Objekte sind in der Regel UI widget…“

Android Development - Hello World

2013-02-26T19:59:44Z

79.240.86.226:

[[Android Development - User Interface programmieren]]

== Wie funktioniert eine klassische Hello World App ? ==
Wenn man in Eclipse eine Android App anlegt wird automatisch eine hello world Anwendung erzeugt.

Beim Start wird die default Activity class gestartet und lädt ein Layout File.

== Eine App testen ==
Entweder mit Handy (USB-Debugging aktivieren) oder mit dem Emulator. Unter Windows braucht man evtl. noch passende Treiber für das Handy. Diese werden oft mit der Standard Hersteller Software mit installiert. Oder mal auf Google suchen.

Unter Eclipse startet man mit Run as > Android Application, die Schritte unten (kompilieren mit ant und installieren mit adb sowie starten auf dem Handy) werden automatisch ausgeführt.

Mit Kommandozeile ins Andwendungsverzeichnis wechseln und
ant debug
adb install bin/MyFirstApp-debug.apk
Und dann auf dem Handy starten

Android Development - Hello World

2013-02-26T19:58:34Z

79.240.86.226: Die Seite wurde neu angelegt: „== Wie funktioniert eine klassische Hello World App ? == Wenn man in Eclipse eine Android App anlegt wird automatisch eine hello world Anwendung erzeugt. Beim S…“

== Wie funktioniert eine klassische Hello World App ? ==
Wenn man in Eclipse eine Android App anlegt wird automatisch eine hello world Anwendung erzeugt.

Beim Start wird die default Activity class gestartet und lädt ein Layout File.

== Eine App testen ==
Entweder mit Handy (USB-Debugging aktivieren) oder mit dem Emulator. Unter Windows braucht man evtl. noch passende Treiber für das Handy. Diese werden oft mit der Standard Hersteller Software mit installiert. Oder mal auf Google suchen.

Unter Eclipse startet man mit Run as > Android Application, die Schritte unten (kompilieren mit ant und installieren mit adb sowie starten auf dem Handy) werden automatisch ausgeführt.

Mit Kommandozeile ins Andwendungsverzeichnis wechseln und
ant debug
adb install bin/MyFirstApp-debug.apk
Und dann auf dem Handy starten

Android Development

2013-02-26T19:58:11Z

79.240.86.226: /* Android Development - First Steps */

== Android Development - First Steps ==
[[Android Development - Hello World]]

[[Android Development - Referenz]]

[[Android Development - Snippets]]

== Android Entwicklungsumgebung ==
=== Eclipse und Android SDK ===
Es gibt ein angepasstes Eclipse Paket mit den Android Tools auf http://developer.android.com/sdk/installing/index.html, das ist der schnellste Weg. Im Folgenden ein Beispiel für die klassische Installation, bei der wir alle Schritte nacheinander durchführen.

==== Benötigte Komponenten ====
Im Einzelnen benötigt man über eine Eclipse / Java IDE noch:
* ADT plugin (Android Developer Tools)
* Android SDK Tools
* Android Platform-tools
* The latest Android platform
* The latest Android system image for the emulator

==== Eclipse Installation ====
http://help.eclipse.org/juno/index.jsp

* Download Eclipse (z.B. Classic)
* Download und Installation des Java JDK (Java Entwickler SDK)
* Registrieren des JDK in Eclipse (Preferences > Java > Installed JREs
==== Android SDK installieren ====
* Android SDK downloaden und installieren (benötigt JDK) Beim ersten Start fragt der SDK Manager welche Tools für welche Android Plattform man nachladen möchte. Wenn man mit Eclipse arbeitet sollte man den '''Manager abbrechen''' und dies später über das Eclipse Plugin machen.
==== ADT Plugin für Eclipse installieren ====
http://developer.android.com/sdk/installing/installing-adt.html

* In Eclipse ''Help > Install New Software''.
* Add Repository Dialog "''ADT Plugin''" als Name und folgende URL angeben:
https://dl-ssl.google.com/android/eclipse/
Bei Problemen mit der Verbindunghttp verwenden.
* Developer Tools auswählen und die Installation fertigstellen.
* Nach der Installation Eclipse neu starten.
* Nach dem Neustart von Eclipse fragt das Plugin nach dem Ort des SDK (wenn er es noch nicht gefunden hat)
* Über Windows SDK-Manager können wir jetzt jederzeit die restlichen Android Komponenten laden die wir benötigen.

Android Development

2013-02-26T19:57:14Z

79.240.86.226: /* Android Development - First Steps */

== Android Development - First Steps ==
[[Android Development - Erste Schritte]]

[[Android Development - Referenz]]

[[Android Development - Snippets]]

== Android Entwicklungsumgebung ==
=== Eclipse und Android SDK ===
Es gibt ein angepasstes Eclipse Paket mit den Android Tools auf http://developer.android.com/sdk/installing/index.html, das ist der schnellste Weg. Im Folgenden ein Beispiel für die klassische Installation, bei der wir alle Schritte nacheinander durchführen.

==== Benötigte Komponenten ====
Im Einzelnen benötigt man über eine Eclipse / Java IDE noch:
* ADT plugin (Android Developer Tools)
* Android SDK Tools
* Android Platform-tools
* The latest Android platform
* The latest Android system image for the emulator

==== Eclipse Installation ====
http://help.eclipse.org/juno/index.jsp

* Download Eclipse (z.B. Classic)
* Download und Installation des Java JDK (Java Entwickler SDK)
* Registrieren des JDK in Eclipse (Preferences > Java > Installed JREs
==== Android SDK installieren ====
* Android SDK downloaden und installieren (benötigt JDK) Beim ersten Start fragt der SDK Manager welche Tools für welche Android Plattform man nachladen möchte. Wenn man mit Eclipse arbeitet sollte man den '''Manager abbrechen''' und dies später über das Eclipse Plugin machen.
==== ADT Plugin für Eclipse installieren ====
http://developer.android.com/sdk/installing/installing-adt.html

* In Eclipse ''Help > Install New Software''.
* Add Repository Dialog "''ADT Plugin''" als Name und folgende URL angeben:
https://dl-ssl.google.com/android/eclipse/
Bei Problemen mit der Verbindunghttp verwenden.
* Developer Tools auswählen und die Installation fertigstellen.
* Nach der Installation Eclipse neu starten.
* Nach dem Neustart von Eclipse fragt das Plugin nach dem Ort des SDK (wenn er es noch nicht gefunden hat)
* Über Windows SDK-Manager können wir jetzt jederzeit die restlichen Android Komponenten laden die wir benötigen.

Android Development - Referenz

2013-02-26T19:56:24Z

79.240.86.226:

Android Development - Referenz

2013-02-26T19:55:21Z

79.240.86.226: /* Wie funktioniert eine klassische Hello World App ? */

== Wichtige Dateien und Ordner Struktur ==

AndroidManifest.xml
Enthält Infos zur App wie z.B. Kompatibilität, SDK etc.
android:targetSdkVersion
sollte möglichst hoch gewählt werden.

src/
Der Hauptordner der die Quellcode Dateien enthält. Normalerweise enthält er eine '''Activity''' Klasse, die aktiviert wird wenn die App gestartet wird.

res/
Enthält die meisten Resourcen. Sie werden meist auf Unterordner verteilt. Gängige sind:
drawable-hdpi/
für grafische Objekte wie Bitmaäs für hdpi Screens.

layout/
für Bildschirm-Layout Dateien
values/
für verschiedene xml-Dateien die Werte enthalten (z.B. Farbdefinitionen oder Strings)

== Wie funktioniert eine klassische Hello World App ? ==
Wenn man in Eclipse eine Android App anlegt wird automatisch eine hello world Anwendung erzeugt.

Beim Start wird die default Activity class gestartet und lädt ein Layout File.

== Eine App testen ==
Entweder mit Handy (USB-Debugging aktivieren) oder mit dem Emulator. Unter Windows braucht man evtl. noch passende Treiber für das Handy. Diese werden oft mit der Standard Hersteller Software mit installiert. Oder mal auf Google suchen.

Unter Eclipse startet man mit Run as > Android Application, die Schritte unten (kompilieren mit ant und installieren mit adb sowie starten auf dem Handy) werden automatisch ausgeführt.

Mit Kommandozeile ins Andwendungsverzeichnis wechseln und
ant debug
adb install bin/MyFirstApp-debug.apk
Und dann auf dem Handy starten

Android Development - Referenz

2013-02-26T19:49:10Z

79.240.86.226: Die Seite wurde neu angelegt: „ == Wichtige Dateien und Ordner Struktur == AndroidManifest.xml Enthält Infos zur App wie z.B. Kompatibilität, SDK etc. android:targetSdkVersion sollte mö…“

Android Development

2013-02-26T19:34:20Z

79.240.86.226:

== Android Development - First Steps ==
[[Android Development - Referenz]]

[[Android Development - Snippets]]

== Android Entwicklungsumgebung ==
=== Eclipse und Android SDK ===
Es gibt ein angepasstes Eclipse Paket mit den Android Tools auf http://developer.android.com/sdk/installing/index.html, das ist der schnellste Weg. Im Folgenden ein Beispiel für die klassische Installation, bei der wir alle Schritte nacheinander durchführen.

==== Benötigte Komponenten ====
Im Einzelnen benötigt man über eine Eclipse / Java IDE noch:
* ADT plugin (Android Developer Tools)
* Android SDK Tools
* Android Platform-tools
* The latest Android platform
* The latest Android system image for the emulator

==== Eclipse Installation ====
http://help.eclipse.org/juno/index.jsp

* Download Eclipse (z.B. Classic)
* Download und Installation des Java JDK (Java Entwickler SDK)
* Registrieren des JDK in Eclipse (Preferences > Java > Installed JREs
==== Android SDK installieren ====
* Android SDK downloaden und installieren (benötigt JDK) Beim ersten Start fragt der SDK Manager welche Tools für welche Android Plattform man nachladen möchte. Wenn man mit Eclipse arbeitet sollte man den '''Manager abbrechen''' und dies später über das Eclipse Plugin machen.
==== ADT Plugin für Eclipse installieren ====
http://developer.android.com/sdk/installing/installing-adt.html

* In Eclipse ''Help > Install New Software''.
* Add Repository Dialog "''ADT Plugin''" als Name und folgende URL angeben:
https://dl-ssl.google.com/android/eclipse/
Bei Problemen mit der Verbindunghttp verwenden.
* Developer Tools auswählen und die Installation fertigstellen.
* Nach der Installation Eclipse neu starten.
* Nach dem Neustart von Eclipse fragt das Plugin nach dem Ort des SDK (wenn er es noch nicht gefunden hat)
* Über Windows SDK-Manager können wir jetzt jederzeit die restlichen Android Komponenten laden die wir benötigen.