Programmier Tutorial - Apps für Android entwickeln - Activities und Intents in Android

Programmier Tutorial: Apps für Android entwickeln – Teil 10: Activities und Intents in Android


Im zehnten Teil unseres großen Android™ Tutorials werden wir unsere AktieHQ App um einen weiteren Bildschirm (Activity) erweitern.

Mit Hilfe der neuen Activity werden wir detaillierte Finanzinformationen zu einem bestimmten Element des ListViews, welcher die Infos für die verschiedenen Finanzinstrumente enthält, anzeigen.

Um die neue Activity zu starten, werden wir den Android Intent Mechanismus verwenden. Intents werden in Android vor allem dazu benutzt, um aus einer Activity eine andere Activity zu starten.

In Android sind Intents von großer Bedeutung und bestimmen wie auf Eingaben des Benutzers reagiert werden soll. Also welche Activity (Bildschirmseite) gestartet werden soll und welche Daten dabei übergeben werden. In dieser Lektion tauchen wir in dieses spannende Android Thema ein und programmieren unseren ersten “Intent“.

Nun wünschen wir euch viel Spaß bei dem zehnten Teil unseres großen Android Tutorials. Los geht’s!

1. Activities und Intents in Android

Eine Android App besteht aus einer oder mehreren Activities. Jede Activity erfüllt eine ganz bestimmte Aufgabe. Eine App kann aus beliebig vielen Activities (Bildschirmseiten) bestehen.

Zwischen den Activities kann, wie oben bereits kurz erwähnt, mit Hilfe von Intents gewechselt werden.

Wir werden zunächst untersuchen, was genau eine Activity im Android System darstellt. Anschließend werden wir Intents näher beleuchten.

Was ist eine Activity in Android?

Normale PC-Anwendungen bestehen meist aus einem Hauptbildschirm, in dem der Benutzer seine Aktionen durchführen kann. Der Hauptbildschirm wird nur sehr selten verlassen.

Android Apps sind anders aufgebaut. Sie bestehen aus einer beliebigen Menge an Bildschirmseiten. Jede Bildschirmseite ist einer bestimmten Aktivität gewidmet, daher die Bezeichnung Activity.

Eine Activity ist als Kombination aus Bildschirmseite und zugehörigem Quellcode zu sehen. Jede Activity sollte genau für eine exakt formulierte Aufgabe verantwortlich sein. Was alle Activities gemein haben, ist dass sie sich von der Klasse android.app.Activity ableiten.

Jede Activity einer App muss außerdem in der AndroidManifest.xml Datei aufgeführt sein.

Dass eine Android App aus mehreren Activities besteht, hat einen großen Vorteil. Denn jede Activity ist ein in sich geschlossenes Element und nur lose in die gesamte App eingebunden. Und genau daraus ergibt sich der große Nutzen des Activity-Mechanismus.

Denn eine Activity kann von anderen Apps aufgerufen werden. Der Aufruf erfolgt über den globalen Aufrufmechanismus von Android mit Hilfe von Intents. Es spielt dabei keine Rolle, ob eine App-eigene Activity aufgerufen wird oder eine Activity einer fremden Activity.

Was ist ein Intent in Android?

Wir haben den Begriff Intent jetzt schon einige mal gelesen. Nun ist es an der Zeit ihm das Unbekannte zu nehmen. Wie oben bereits mehrfach erwähnt, werden in Android mit Hilfe von Intents andere Activities gestartet.

Dabei stellt ein Intent (dt. Absicht) eine lose Verbindung zwischen der aufrufenden (Adressant) und der aufgerufenen (Adressat) Activity dar. Diese Verbindung ist exakt definiert, so dass zum Starten einer Activity immer folgende Schritte durchgeführt werden müssen:

  1. Erzeugen eines Intent-Objekts
  2. Angeben welche Activity aufzurufen ist und welche Daten dieser zu übergeben sind
  3. Abschicken des Intents

Nachdem der Intent abgeschickt wurde, kümmert sich das Android System um die weitere Verarbeitung. Es wird nach der auszuführenden Activity gesucht und, wenn eine passende gefunden wurde, diese gestartet.

Für die Angabe des Empfängers, die App die gestartet werden soll, kann zwischen den folgenden beiden Vorgehen gewählt werden:

  • Expliziter Intent – Hierbei wird die aufzurufende Activity direkt angegeben.
  • Impliziter Intent – Es wird keine konkrete Activity als Empfänger (Adressat) angegeben. Dafür wird dem Android System aber mitgeteilt welche Aktion durchgeführt werden soll, durch Angabe von action, data und category. Das Android System bestimmt anschließend welche der auf dem Gerät vorhandenen Activities die Aktion durchführen kann. Damit dieser Mechanismus reibungslos funktioniert, benötigt das Android System die Unterstützung der Activities, die mit Intent-Filtern über ihre Fähigkeiten berichten.

Sehr detaillierte und weiterführende Informationen über Activities und Intents könnt ihr auf der Developer-Seite von Android an folgenden Stellen finden:

2. ClickListener dem ListView hinzufügen

Bisher zeigt unsere Android App die Aktiendaten nur in einem ListView an. Die Liste lässt sich nur scrollen und reagiert nicht auf Benutzerinteraktionen.

Das wollen wir nun ändern.

Es soll möglich sein, mit einem Klick auf ein beliebiges Listenelement, sich weitere Finanzdetails anzeigen zu lassen.

Dabei hilft uns ein ClickListener, der auf Klicks der Benutzer reagiert. Wir benutzen dafür das Interface OnItemClickListener, welches auf kurze Klicks auf Elemente des zugrunde liegenden AdapterViews achtet.

2.1 Den OnItemClickListener an den ListView binden

Wir registrieren einen OnItemClickListener für unseren ListView, welcher die Liste mit Finanzinformationen enthält. Dazu verwenden wir die Methode setOnItemClickListener. Dadurch wird automatisch ein Callback aufgerufen und unser hinterlegter Code ausgeführt, sobald vom Benutzer auf ein Listenelement geklickt wurde.

Mehr Infos über den OnItemClickListener findet ihr hier auf der Android-Developer Seite.

Zuerst muss die folgende Import-Anweisung oben im Quellcode der Klasse AktienlisteFragment.java eingefügt werden:


Um den OnItemClickListener zu registrieren, fügen wir folgenden gelb hervorgehobenen Quellcode in der Datei AktienlisteFragment.java ein:


Durch den oberen Code-Block überwacht ein OnItemClickListener unseren aktienlisteListView. Wird ein Element des ListViews angeklickt, dann wird automatisch die überschriebene Methode onItemClick aufgerufen mit den folgenden Parametern:

  • AdapterView adapterView – Der AdapterView bei dem der Klick stattfand.
  • View view – Der View innerhalb des angeklickten AdapterViews.
  • int position – Die Position des Views im Adapter.
  • long id – Die Reihen-ID des angeklickten Elements.

Mit Hilfe der übergebenen Position können wir den Inhalt des angeklickten Listenelements auslesen. Dies geschieht in Zeile 9. Die ausgelesene Finanzinformation speichern wir in der String Variable aktienInfo kurz zwischen.

Um die Funktion unseres registrierten OnItemClickListener schnell testen zu können, haben wir in Zeile 10 einen Toast erzeugt und lassen damit die ausgelesene Aktieninformation des Listenelements auf dem Android Smartphone oder Tablet kurz anzeigen.

Zur Übersicht könnt ihr euch auch den gesamten Quelltext der Klasse AktienlisteFragment.java noch einmal in Ruhe anschauen:

AktienlisteFragment.java (als ZIP-Datei gepackt)

2.2 Testen des OnItemClickListeners auf dem Android Gerät

Nun möchten wir unsere jetzt anklickbare Liste auch einmal in Aktion sehen. Dazu installieren und starten wir unsere AktieHQ App wie in Abschnitt 9 beschrieben.

Die untere Abbildung zeigt das Verhalten unserer Android App:

app android intent

Werden die ListView Elemente angeklickt, so erscheint ein Toast mit den entsprechenden Aktieninfos

Durch den OnItemClickListener werden Klicks, die der Benutzer auf dem ListView durchführt, erkannt und unsere Android App reagiert darauf. Momentan lassen wir die angeklickte Finanzinformation noch als kleinen Toast kurz einblenden, als Nächstes möchten wir jedoch die Info in einer weiteren Bildschirmseite (Activity) anzeigen lassen.

Doch für den Moment sind wir ganz zufrieden, dass die Aktieninfo-Liste unserer App jetzt auf Benutzereingaben reagiert.

2.3 Video – Reagieren auf Benutzereingaben (Klicks)

Zur besseren Verdeutlichung der Funktionsweise unserer Android App, haben wir das folgende Video erstellt, in dem das oben Beschriebene noch einmal in bewegten Bildern zu sehen ist:

Wie im oberen Video zu sehen ist, reagiert die Liste in unserer App jetzt auf Benutzereingaben. Das Anzeigen der Finanzinfo als Toast ist schön anzusehen, war aber nur für Testzwecke gedacht.

Dieses Verhalten wollen wir nun ändern und bei einem Klick auf ein Listenelement eine neue Bildschirmseite (Activity) öffnen. Dies werden wir in den nächsten Abschnitten in die Tat umsetzen.

3. Eine Menü-Datei für die neue Activity anlegen

In den nächsten Abschnitten werden wir eine neue Activity mit einem eigenen Fragment anlegen. Die Activity soll über ein eigenes Menü verfügen, dessen Einträge sich in dem Options Menu befinden sollen. Bevor wir das Menü der Activity zuweisen können, müssen wir vorher eine entsprechende Menü Ressourcen-Datei erstellen. Dies werden wir nun tun.

Die neue Menü Ressourcen-Datei legen wir folgendermaßen an:

  1. Mit der rechten Maustaste auf den menu Ressourcen-Ordner klicken.
  2. Anschließend in dem Kontext-Menü den Eintrag New anklicken.
  3. Schließlich klicken wir auf den Eintrag Menu resource file.
android intent menu create

Erstellen der Menü Ressourcen Datei menu_aktiendetail.xml in Android Studio

Anschließend öffnet sich der New Menu Resource File-Dialog. Wir geben menu_aktiendetail als Dateinamen für die zu erstellende Menü Ressourcen-Datei ein. Die Dateiendung xml müssen wir nicht angeben, dies übernimmt Android Studio automatisch für uns.

android intent menu filename

Dateinamen für die neue Menü Ressourcen Datei festlegen.

Jetzt erstellt Android Studio die neue Menü-Datei und öffnet diese automatisch im Editorfenster. Wir ersetzen nun den angezeigten Quellcode mit dem folgenden Code:


Das so definierte Menü wird später noch weitere Einträge erhalten. Für den Moment besteht es aus einem Eintrag mit dem Titel Settings.

In Android Studio sollte die Menü Ressourcen-Datei menu_aktiendetail.xml nun wie folgt aussehen:

android intent menu code

Die Menü Ressourcen Datei menu_aktiendetail.xml mit den vorgenommenen Änderungen

Nun haben wir die Menü-Datei für die neue Activity angelegt. Bevor wir die Activity selbst anlegen, werden wir vorher noch ihr Fragment erstellen. Dies werden wir uns im nächsten Abschnitt vornehmen.

4. Ein Fragment für die neue Activity anlegen

Nun werden wir unserem Android Projekt ein weiteres Fragment hinzufügen. Dieser Prozess besteht aus zwei Arbeitsschritten:

  1. Erstellen der Layout Ressourcen-Datei des Fragments
  2. Erstellen der Klassendatei des Fragments

Beginnen wir nun mit dem ersten Arbeitsschritt.

4.1 Erstellen der Layout-Datei des neuen Fragments

Die neue Layout Ressourcen-Datei legen wir folgendermaßen an:

  1. Mit der rechten Maustaste auf den layout Ressourcen-Ordner klicken.
  2. Anschließend in dem Kontext-Menü den Eintrag New anklicken.
  3. Schließlich klicken wir auf den Eintrag Layout resource file.
android intent fragment layout create

Erstellen der Layout Ressourcen Datei fragment_aktiendetail.xml in Android Studio

Anschließend öffnet sich der New Layout Resource File-Dialog. Wir geben fragment_aktiendetail als Dateinamen für die zu erstellende Layout Ressourcen-Datei ein. Die Dateiendung xml müssen wir nicht angeben, dies übernimmt Android Studio automatisch für uns.

android intent fragment layout filename

Dateinamen für die neue Layout Ressourcen Datei festlegen.

Jetzt erstellt Android Studio die neue Layout-Datei für das Fragment und öffnet diese automatisch im Editorfenster. Wir ersetzen nun den angezeigten Quellcode mit dem folgenden Code:


Das so definierte Layout werden wir im nächsten Arbeitsschritt mit dem neuen Fragment verknüpfen. Es wird das Aussehen des neuen Fragments definieren.

In Android Studio sollte die Layout Ressourcen-Datei fragment_aktiendetail.xml nun wie folgt aussehen:

android intent fragment layout code

Die Layout Ressourcen Datei fragment_aktiendetail.xml mit den vorgenommenen Änderungen

Nun haben wir ein Layout für das neue Fragment definiert. Es enthält ein TextView-Element, in dem wir später die Aktiendetails ausgeben werden. Jetzt werden wir das Fragment selbst anlegen und es mit der eben erstellten Layout Ressourcen-Datei verknüpfen.

Es kann sein, dass Android Studio den Wert des Attributs tools:context mit roter Schrift darstellt und als Fehler markiert. Dies ist kein Problem und wird schon im nächsten Arbeitsschritt behoben, wenn wir die Klassendatei des neuen Fragments anlegen.

4.2 Erstellen der Klassendatei des neuen Fragments

Die neue Klassendatei AktiendetailFragment.java legen wir folgendermaßen an:

  1. Mit der rechten Maustaste auf das Package de.programmierenlernenhq.aktiehq.app klicken.
  2. Anschließend in dem Kontext-Menü den Eintrag New anklicken.
  3. Schließlich klicken wir auf den Eintrag Java Class.
android intent fragment class create

Erstellen der Klassendatei AktiendetailFragment.java in Android Studio

Anschließend öffnet sich der New Java Class-Dialog. Wir geben AktiendetailFragment als Dateinamen für die zu erstellende Java Klasse ein. Die Dateiendung java müssen wir nicht angeben, dies übernimmt Android Studio automatisch für uns.

android intent fragment class filename

Dateinamen für die neue Klassendatei festlegen.

Jetzt erstellt Android Studio die neue Klassendatei für das Fragment und öffnet diese automatisch im Editorfenster. Wir ersetzen nun den angezeigten Quellcode mit dem folgenden Code:


Mit dem oberen Quellcode haben wir das neue Fragment definiert. Es besteht aus einem Konstruktor und der Callback-Methode onCreateView(), in der wir das Fragment-Layout laden. Dazu greifen wir auf die Layout Ressourcen-Datei fragment_aktiendetail.xml zu.

Das so definierte Fragment werden wir im nächsten Abschnitt einer Activity hinzufügen. In Android Studio sollte die Klassendatei AktiendetailFragment.java nun wie folgt aussehen:

android intent fragment class code

Die Klassendatei AktiendetailFragment.java mit den vorgenommenen Änderungen

Jetzt ist es an der Zeit die neue Activity AktiendetailActivity anzulegen. Dies werden wir im nächsten Abschnitt durchführen.

5. Die Activity AktiendetailActivity anlegen

Nun werden wir unserem Android Projekt eine weitere Activity hinzufügen. Dieser Prozess besteht aus drei Arbeitsschritten:

  1. Erstellen der Layout Ressourcen-Datei der Activity
  2. Erstellen der Klassendatei der Activity
  3. Definieren einer String-Konstante für den Titel der Activity

Beginnen wir nun mit dem ersten Arbeitsschritt.

5.1 Erstellen der Layout-Datei der neuen Activity

Die neue Layout Ressourcen-Datei legen wir folgendermaßen an:

  1. Mit der rechten Maustaste auf den layout Ressourcen-Ordner klicken.
  2. Anschließend in dem Kontext-Menü den Eintrag New anklicken.
  3. Schließlich klicken wir auf den Eintrag Layout resource file.
android intent activity layout create

Erstellen der Layout Ressourcen Datei activity_aktiendetail.xml in Android Studio

Anschließend öffnet sich der New Layout Resource File-Dialog. Wir geben activity_aktiendetail als Dateinamen für die zu erstellende Layout Ressourcen-Datei ein. Die Dateiendung xml müssen wir nicht angeben, dies übernimmt Android Studio automatisch für uns.

android intent activity layout filename

Dateinamen für die neue Layout Ressourcen Datei festlegen.

Jetzt erstellt Android Studio die neue Layout-Datei für die Activity und öffnet diese automatisch im Editorfenster. Wir ersetzen nun den angezeigten Quellcode mit dem folgenden Code:


Das so definierte Layout werden wir im nächsten Arbeitsschritt mit der neuen Activity verknüpfen. Es wird das Aussehen der AktiendetailActivity definieren.

In Android Studio sollte die Layout Ressourcen-Datei activity_aktiendetail.xml nun wie folgt aussehen:

android intent activity layout code

Die Layout Ressourcen Datei activity_aktiendetail.xml mit den vorgenommenen Änderungen

Nun haben wir ein Layout für die neue Activity definiert. Es enthält ein Fragment-Element, in dem wir das AktiendetailFragment anzeigen. Jetzt werden wir die Activity selbst anlegen und ihr die eben erstellte Layout Ressourcen-Datei zuweisen.

5.2 Erstellen der Klassendatei der neuen Activity

Die neue Klassendatei AktiendetailActivity.java legen wir folgendermaßen an:

  1. Mit der rechten Maustaste auf das Package de.programmierenlernenhq.aktiehq.app klicken.
  2. Anschließend in dem Kontext-Menü den Eintrag New anklicken.
  3. Schließlich klicken wir auf den Eintrag Java Class.
android intent activity class create

Erstellen der Klassendatei AktiendetailActivity.java in Android Studio

Anschließend öffnet sich der New Java Class-Dialog. Wir geben AktiendetailActivity als Dateinamen für die zu erstellende Java Klasse ein. Die Dateiendung java müssen wir nicht angeben, dies übernimmt Android Studio automatisch für uns.

android intent activity class filename

Dateinamen für die neue Klassendatei festlegen.

Jetzt erstellt Android Studio die neue Klassendatei für die Activity und öffnet diese automatisch im Editorfenster. Wir ersetzen nun den angezeigten Quellcode mit dem folgenden Code:


Mit dem oberen Quellcode haben wir die neue Activity definiert. Sie besteht aus drei Callback-Methoden, mit denen wir das Layout laden und das Menü initialisieren. Dazu greifen wir auf die Layout Ressourcen-Dateien activity_aktiendetail.xml und menu_aktiendetail.xml zu.

In Android Studio sollte die Klassendatei AktiendetailActivity.java nun wie folgt aussehen:

android intent activity class code

Die Klassendatei AktiendetailActivity.java mit den vorgenommenen Änderungen

Die neue Activity AktiendetailActivity wurde somit erstellt. Bevor wir sie in der AndroidManifest.xml Datei bekannt geben können, müssen wir noch einen Titel für sie als String-Konstante definieren.

5.3 Definieren einer String-Konstante für den Titel der Activity

Als letzten Arbeitsschritt legen wir den Titel unserer neuen Activity fest. Wir öffnen dazu die strings.xml Ressourcen-Datei und fügen in sie die folgende Zeile ein:


In Android Studio sollte die strings.xml Datei nun folgendermaßen aussehen:

android intent activity string code

Definieren einer String-Konstante für den Titel der Activity

Jetzt haben wir alle Vorbereitungen für die neue Activity AktiendetailActivity mit ihrem inneren Fragment und Menü abgeschlossen. Als Nächstes müssen wir die Activity in unserer Android App bekannt machen. Dies erfolgt in der AndroidManifest.xml Datei.

6. Die neue Activity im AndroidManifest bekanntgeben

Um die neue Activity AktiendetailActivity in unserer App bekannt zu machen, öffnen wir die Datei AndroidManifest.xml im Editorfenster von Android Studio.

Wir fügen nun die folgenden Zeilen in die AndroidManifest.xml Datei ein:


Die Datei AndroidManifest.xml sollte nun wie folgt in Android Studio aussehen:

android intent manifest

Die AndroidManifest.xml Datei mit den vorgenommenen Änderungen

Mit diesem Arbeitsschritt haben wir das Anlegen der neuen Activity abgeschlossen. Die AktiendetailActivity haben wir nun in unserer Schaltzentrale bekanntgegeben und ihr dabei auch einen Titel (label) zugewiesen. Wir sind nun bereit die neue Activity mit Hilfe eines Intents zu starten.

In unserem Android Projekt sollten jetzt diese fünf neuen Dateien erstellt worden sein:

  1. Code-Datei: AktiendetailActivity
  2. Code-Datei: AktiendetailFragment
  3. Layout-Datei: activity_aktiendetail.xml
  4. Layout-Datei: fragment_aktiendetail.xml
  5. Menü-Datei: menu_aktiendetail.xml
android intent new files

Neu erstellte und überarbeitete Dateien

Außerdem wurden die beiden orange markierten Dateien strings.xml und AndroidManifest.xml überarbeitet.

7. Mit einem expliziten Intent die neue Activity starten

Die neue Activity starten wir mit einem expliziten Intent. Bei einem expliziten Intent wird die aufzurufende Activity explizit angegeben. In unserem Fall ist das die Activity AktiendetailActivity.

Wir erstellen das benötigte Intent-Objekt mit dem Konstruktor Intent(Context, Class):

  • Als Context geben wir die aktuelle Activity mit getActivity() an.
  • Als Class geben wir die Klasse der aufzurufenden Activity mit AktiendetailActivity.class an.

Das ist auch schon alles. Mit diesem erzeugten Intent können wir unsere neue Activity starten. Aber vorher möchten wir dem Intent noch als Daten die Aktieninformation für das angeklickte Finanzinstrument aus dem ListView übergeben.

Dies führen wir mit folgender Anweisung aus:

aktiendetailIntent.putExtra(Intent.EXTRA_TEXT, aktienInfo);

Dabei ist EXTRA_TEXT ein vordefinierter Schlüssel, zu dem wir einen String-Wert ablegen können. Den abgelegten Wert können wir dann in der aufgerufenen Activity wieder auslesen. Dieser Weg ermöglicht eine einfache Datenübergabe von der einen Activity zur anderen.

Da jetzt unser Intent über die beiden Angaben aufzurufende Activity und zu übermittelnde Daten verfügt, können wir ihn mit startActivity(aktiendetailIntent); starten.

Wir fügen die eben beschriebenen Code-Zeilen in unser Projekt in die Datei AktienlisteFragment.java ein. Dabei müssen wir den unter Abschnitt 2 eingefügten Toast wieder entfernen und an dessen Stelle den gelb hervorgehobenen Quellcode einfügen:


Damit wir Intents auch erzeugen können, müssen wir die Intent-Klasse mit dem Import-Befehl am Anfang unserer AktienlisteFragment-Klasse importieren. Dazu verwenden wir folgende Anweisung:


Mit den Änderungen im Quellcode ist unsere App nun in der Lage eine zweite Activity zu starten.

Zur Übersicht könnt ihr euch den aktuellen Quelltext der Klasse AktienlisteFragment.java noch einmal in Ruhe anschauen:

AktienlisteFragment.java (als ZIP-Datei gepackt)

Nun möchten wir unseren Intent auch einmal in Aktion sehen. Dazu installieren und starten wir unsere AktieHQ App wie in Abschnitt 9 beschrieben.

Die untere Abbildung zeigt das momentane Verhalten unserer Android App:

android intent start

Werden die ListView Elemente angeklickt, so startet jetzt die neue Activity “Aktiendetail”

Wie in der oberen Abbildung zu sehen ist, werden momentan noch keine Aktiendetails in der neuen Activity AktiendetailActivity angezeigt. Um dies zu ändern, werden wir im nächsten Abschnitt die mit dem Intent übermittelten Finanzinformationen auslesen und auf der Bildschirmseite anzeigen.

Es lohnt sich zudem sehr, die weiterführenden Informationen über das Starten einer Activity und Activities allgemein auf der Android Developer Webseite in Ruhe zu studieren.

8. Übermittelte Aktiendetails in neuer Activity anzeigen

Nun ist es fast geschafft.

Um die Aktiendetails aus dem empfangenen Intent auszulesen und sie im TextView des Fragments der neuen Activity anzuzeigen, müssen wir noch eine Änderung an der AktiendetailFragment.java Datei vornehmen.

Wir öffnen daher die Quelldatei unseres Fragments AktiendetailFragment und fügen den gelb markierten Code-Block in die onCreateView-Methode der Klasse ein:


Mit dem oben markierten Quellcode erzeugen wir eine Variable vom Datentyp Intent und weisen ihr das empfangene Intent-Objekt zu. Anschließend prüfen wir, ob der Intent auch Daten enthält.

Ist dies der Fall, lesen wir die übermittelte Finanzinformation aus dem Intent-Objekt aus und speichern sie in dem String aktienInfo ab. Über die Methode findViewById suchen wir nach dem TextView unseres Fragments und speichern unsere Aktieninformation darin.

Zusätzlich müssen wir noch die folgenden beiden Import-Anweisungen an den Beginn des Quellcodes angeben:


Es ist empfehlenswert sich die beiden unten aufgeführten Quellcode-Dateien herunter zu laden und sie in Ruhe zu betrachten. Dadurch werden die, in diesem Abschnitt beschriebenen, Änderungen besser nachvollziehbar.

Die beiden vollständigen Quelltexte zum Download:

AktiendetailFragment.java (als ZIP-Datei gepackt)
fragment_aktiendetail.xml (als ZIP-Datei gepackt)

9. Testen unserer Android App und Starten der neuen Activity mit Hilfe eines expliziten Intents

Alle notwendigen Änderungen an den Quelltexten unseres Android Projekts sind vorgenommen. Nun wollen wir unsere App testen. Dazu installieren wir die Anwendung auf unser angeschlossenes Android Gerät (Smartphone oder Tablet) und lassen sie dort ausführen.

Um die App auf dem Android Gerät starten zu können, müssen alle Schritte von Teil 3 des Android Tutorials befolgt worden sein.

Hier noch einmal in Kürze die wichtigsten Arbeitsschritte.

Zuerst schließen wir unser Android Gerät an den PC an und stellen eine Verbindung über die ADB (Android Debug Bridge) her. Danach klicken wir auf das Run 'app'-Symbol. Unser Android Projekt wird dadurch neu erstellt und auf dem angeschlossenen Gerät ausgeführt.

Das Run 'app'-Symbol befindet sich in der oberen Menüleiste, siehe folgende Abbildung:

android studio project avd run

Android App über das Run App-Symbol starten

Nach einigen Momenten öffnet sich der Select Deployment Target-Dialog. In ihm nehmen wir die folgenden Einstellungen vor:

  1. Das angeschlossene Android Gerät unter Connected Devices auswählen.
  2. Mit einem Klick auf den OK-Button die Installation unserer App auf das Gerät starten.
android device run app

Auswählen des angeschlossenen Android Geräts zum Aufspielen unserer App

Der Dialog schließt sich und unsere Android App wird auf das angeschlossene Gerät übertragen und installiert. Die Installation dauert nur einen kurzen Augenblick und verläuft fast unbemerkt im Hintergrund. Danach wird unsere App automatisch gestartet.

9.1 Neue Activity mit Hilfe eines expliziten Intents starten

Zu Beginn sehen wir die alten Beispiel-Aktiendaten (mock data) in unserem ListView. Um die simulierten Online-Aktiendaten bei unserem Web-Server abzufragen, müssen wir auf den Aktualisieren-Button im Overflow Menu klicken.

Jetzt werden die aktuellen Aktiendaten über das Internet geladen und in dem ListView angezeigt. Mit einem Klick auf ein beliebiges Listenelement starten wir die neue Activity AktiendetailActivity mit einem Intent. Dabei übergeben wir ihr die Finanzinformationen des angeklickten Listenelements.

Die übermittelten Aktiendetails lesen wir aus dem empfangenen Intent aus und zeigen sie in dem TextView der neuen Activity an.

Die folgende Abbildung zeigt, wie unsere Android App die Aktiendaten in der neuen Activity anzeigt:

android intent activity

Wird ein ListView-Element angeklickt, werden die entsprechenden Aktiendaten in der neuen Activity angezeigt

Mit dem Up-Button gelangen wir wieder zurück in die Haupt-Aktivität. Dabei gehen aber alle geladenen Online-Finanzdaten verloren, da die Activity neu erzeugt wird und dabei wieder die Beispieldaten in den ListView eingefügt werden.

Dieses fehlerhafte Verhalten werden wir später korrigieren, aber für den Moment ist es so OK.

Navigieren wir aber mit dem Back-Button zurück in die MainActivity, tritt dieses Fehlverhalten nicht auf, da die Activity nicht neu erstellt wird, sondern die bereits erzeugten Elemente angezeigt werden. So auch die geladenen Online-Aktiendaten.

9.2 Video – Starten der neuen Activity mit einem Intent

Nun möchten wir unsere Android App auch einmal in der aktuellen Entwicklungsstufe im Video sehen. Dazu haben wir das folgende kurze Video erstellt, in dem die neue Funktion unserer App vorgestellt wird:

Zuerst sieht man die App im Startzustand. Mit einem Klick auf den Aktualisieren-Button wird der asynchrone Task HoleDatenTask im Hintergrund gestartet.

Der asynchrone Task fragt zuerst die simulierten Online-Aktiendaten bei unserem Web-Server im XML-Format für die Finanzinstrumente ab und liest die empfangenen XML-Daten anschließend aus. Dabei werden die relevanten Finanzinformationen (Preis, Änderung in Prozent, Symbol und Name) in den ListView eingefügt und auf dem Android Gerät angezeigt.

Mit einem Klick auf ein Listenelement wird die neue Activity AktiendetailActivity gestartet. Dies erfolgt mit Hilfe eines expliziten Intents. Das Intent enthält die Aktiendaten des angeklickten Listenelements.

Die neue Activity empfängt das Intent und die übermittelten Aktiendaten. Die Daten werden ausgelesen und in dem TextView angezeigt. Mit einem Klick auf den Back-Button wechseln wir zurück in die Haupt-Aktivität MainActivity unserer Android App.

Später im Video klicken wir auf den Up-Button und navigieren dadurch zurück in die hierarchisch übergeordnete Aktivität. Dabei gehen aber alle bisherigen Finanzinformationen verloren, da die MainActivity in diesem Fall neu angelegt wird.

Dieses unschöne Verhalten unserer App werden wir in einer späteren Lektion des Android Tutorials korrigieren. In der aktuellen Version ist es aber zu verschmerzen.

Zusammenfassung

In diesem Teil des großen Android Tutorials haben wir Activities und Intents kennengelernt. Dabei haben wir erfahren, was Activities und Intents in Android sind und wie sie in dem Android System zusammenspielen.

Anschließend haben wir für den ListView unserer App einen OnItemClickListener registriert, mit dessen Hilfe wir auf Benutzereingaben reagieren. Zum Testen haben wir bei einem Klick auf ein Listenelement einen kleinen Toast einblenden lassen.

Im Hauptteil dieser Lektion haben wir dann eine neue Activity mit einem inneren Fragment in Android Studio erstellt. Die neue Activity haben wir dann mit einem Intent gestartet.

Danach wurde das Fragment der neuen Activity AktiendetailFragment erweitert, so dass es jetzt den Inhalt des empfangenen Intents auslesen und im TextView ausgeben kann.

Abschließend haben wir die AktieHQ App auf dem Android Gerät installiert und ausgeführt. Mit dem oberen Video haben wir den aktuellen Entwicklungsstand unserer Anwendung vorgestellt.


Comments 19

  1. Pingback: Android Tutorial: XML-Daten auslesen und anzeigen in Android

  2. Pingback: Android Tutorial: Mit impliziten Intent eine andere App aufrufen

  3. Pingback: Android Tutorial: Der ShareActionProvider in Android

  4. hey das tutorial ist super, ich habe aber ein kleines Problem, Erstens hast du eigentlich diese Mockdaten rausgenommen, denn beim Appstart würde ja sonst immer erst diese Liste mit den Mockdaten ( Aktienkurse ) angezeigt werden ? Und dann habe ich noch das Problem dass die App oft abstürzt wenn ich die Daten von Yahoo hole ( also den Asynctask starte )und ich nicht weiss warum.

    1. Post
      Author

      Hallo Dennis,

      die Mockdaten werden auch am Ende des Android-Tutorials nicht rausgenommen, da es nur eine Beispiel-App ist. Bei einer realen App würden die Mockdaten natürlich so durch echte Daten ersetzt werden, dass schon beim Starten der App echte Daten angezeigt werden.

      Manchmal endet die HTTP-Anfrage nicht korrekt. Dann werden keine Aktiendaten von Yahoo! zurückgeliefert. In einem solchen Fall stürzt die App bspw. ab. Das ist auch bei mir schon ab und zu passiert. Da es nur eine Beispiel-App ist, wurde auf das Abfangen viele möglicher Fehler verzichtet, damit die Lerninhalte nicht zu komplex und unübersichtlich werden. Eine reale App müsste deutlich stärker debugged werden, da Programmabstürze die User sehr verärgern…

      Viele Grüße, Chris

  5. Hallo Chris,

    vorweg ein super Tutorial, bisher funktioniert alles bestens. Danke dafür!

    Nun mal ne Anmerkung, obwohl ich nicht weiß, ob der Fehler bei mir oder bei Dir liegt.

    Unter Punkt 2.1 in diesem Tutorial hast Du folgenden Quellcode in der AktienlisteFragment.java:

    ListView vorhersageListView = (ListView) rootView.findViewById(R.id.listview_vorhersage);
    vorhersageListView.setAdapter(mVorhersageAdapter);

    und ich habe folgenden Quellcode in meiner Datei:

    ListView aktienlisteListView = (ListView) rootView.findViewById(R.id.listview_aktienliste);
    aktienlisteListView.setAdapter(mAktienlisteAdapter);

    Der Unterschied ist, dass Du “mVorhersageAdapter” und ich “mAktienlisteAdapter” habe, obwohl ich das gesamte Tutorial bis hier komplett durch habe.

    Hab ich im Tutorial irgendwas übersehen? Geht es noch Jemandem so wie mir?

    Ich möchte nur nicht, dass am Ende des Tutorials irgendwas nicht funktioniert, weil es unterschiedliche Bezeichnungen gibt.

    Danke im voraus für deine Antwort!

    Gruß Matze

    1. Post
      Author

      Hallo Matze,

      vielen Dank für die lobenden Worte und den Quellcode-Hinweis.

      Ja, in der Tat hat sich da bei mir ein Fehler eingeschlichen. Ich habe den Quellcode korrigiert, so dass er jetzt Deinem Quellcode entspricht.

      Die unterschiedliche Bezeichnung im Quellcode lag daran, dass ich in diesem Tutorial vorher eine Wetter-App programmiert hatte und diese dann auf eine Aktien-App umgestellt habe. Der mVorhersageAdapter war noch ein Überbleibsel aus der Wetter-App (die Wettervorhersage).

      Viele Grüße und nochmals danke für Deine Hilfe, Chris

  6. Hi Chris,

    bin weiterhin begeistert dabei 😉 1a – dieses Tutorial!!!

    Eine Frage: nach Erzeugen des Intents wird eine “Activity” gestartet, die Daten werden aber letztlich von einem “Fragment” angezeigt. Verstehe ich es richtig, dass beim Start der Activity alle untergeordneten/zugehörigen Fragments (hier: AktiendetailFragment) die onCreate-Methode durchlaufen und jedes Fragment für sich “entscheidet”, ob es den Intent und die im Intent übergebenen Extra-Daten verarbeitet und anzeigt?

    Gruß, Reinhard

    1. Post
      Author

      Hallo Reinhard,

      in Android gibt es den Activity Lifecycle und den Fragment Lifecycle. Wir haben Teil 15 diesem spannenden Thema gewidmet: Der Activity und Fragment Lifecycle in Android.

      Ja es ist so, wie Du sagst. In den verschiedenen Lifecycle-Callbacks der Fragmente kann mittels Intent empfangenerIntent = getActivity().getIntent(); auf den Intent und dessen Inhalte zugegriffen werden. Jedes Fragment kann damit machen was es will.

      Viele Grüße, Chris

  7. Hallo Chris

    Ich hab’ auf gut Schweizerdeutsch immer noch ein Gnusch (eine Verwirrung) was die Verbindungen zwischen den XMLs und den Java Klassen anbelangt. Liegt wohl an mir. Doch eine Frage: Wäre es nicht möglich, das aktiendetail_fragment in der main activity zu zeigen, anstelle der Aktienliste?

    Gruss,

    André

    1. Post
      Author
  8. Hallo Chris,

    nun am Ende des Wochenendes bin ich – erfolgreich – am Ende von Lektion 10, wie von Dir bei meiner Frage zu L. 6 empfohlen. Mein Kopf “raucht”, doch so soll es wohl sein …
    Warum wird man beim Installieren der App im AS nicht gefragt (wg. der Internet permission), ob man installieren möchte? Ist das normal so?
    Bitte um Nachsicht!
    Viele Grüße
    Fido

    1. Post
      Author

      Hallo Fido,

      die Frage habe ich mir auch kürzlich gestellt.

      Wird die App durch Android Studio aufgespielt, werden die angefragten Genehmigungen (Permissions) automatisch vergeben. Würde die App über den Google Play Store installiert werden, wäre das Verhalten anders.

      Viele Grüße, Chris

  9. Chris, du bist echt toll. Danke, danke, danke, danke, danke für dieses tolle Tutorium, du glaubst nicht, wie viel du mir damit hilfst! Vielen, vielen Dank!!

    1. Post
      Author

      Hallo Susi,

      danke für dein Lob! Ich erkläre es hiermit zum Lob des Monats 🙂

      Es freut mich immer sehr, wenn das Tutorial hilfreich ist und mir davon berichtet wird. Das schafft Motivation es beim nächsten Mal noch besser zu machen.

      Viele Grüße, Chris

  10. Hallo Chris,

    danke für die tolle Tutorialreihe.

    Ich stehe jetzt am Ende von Teil 10, habe bisher viele Dinge gelernt und auch noch viele Dinge nicht verstanden. Abgesehen davon bin ich auf ein Problem gestoßen.

    Die App verhält sich im Emulator wie gewollt, auf einem Smartphone nicht. Bis zur Implementierung der Activities/Intents war alles gut, jetzt passiert beim Klick auf die einzelnen Kurse auf dem Smartphone nichts (im Gegensatz zur Emu).

    Hast du einen Tipp für mich?

    Gruß Tino
    P.S.: Emu: Nexus5 mit Android 6 / Smartphone: Xperia Z3 mit Android 6

    1. Post
      Author

      Hallo Tino,

      danke für’s Lob.

      Leider habe ich kein übereinstimmendes Testgerät. Zur Fehlersuche würde ich im Debugger von Android Studio die Zeile als Breakpoint markieren, in der die andere Activity aufgerufen wird. Dann würde ich die vom Debugger angezeigten Werte (der relevanten Variablen) miteinander vergleichen. Also die Werte beim Ausführen im Emulators mit den Werten beim Ausführen auf dem Smartphone. Eventuell lässt sich dann erkennen, was auf dem Smartphone zu dem Problem führt.

      Viele Grüße, Chris

  11. Hallo Chris,

    das Tutorial ist echt klasse! Leider hänge ich gerade am Punkt 9.1. Sobald ich die Daten aktualisiert und auf eine der 3 Aktien geklickt habe, springt er zur Hauptansicht zurück und im Log bekomme ich:
    “D/AbsListView: Get MotionRecognitionManager”
    Kannst du mir bitte weiterhelfen? Ich nutze ein Samsung-Tablet mit Android 4.4.2

    Gruß Christian

    1. Post
      Author

      Hallo Christian,

      hmm, schwierig ohne Quellcode zu beurteilen.

      Wenn du möchtest, kannst Du mir deine Projektdateien (den ganzen Android Studio Projektordner, aber OHNE die build-Unterordner) als ZIP per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Ich schaue dann mal, ob ich etwas herausfinden kann.

      Viele Grüße, Chris

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.