Android_Tutorial_Lektion20_fotolia_RA_Studio_46292813

Programmier Tutorial: Apps für Android entwickeln – Teil 20: Mit einem ListView auf Benutzereingaben reagieren

In der vorherigen Lektion haben wir erfahren, wie vom Android System Benutzereingaben überwacht und behandelt werden. Dabei haben wir die Event Listener der Android Platform näher kennengelernt und einen OnClickListener für den Hole Daten-Button registriert.

In dieser Lektion werden wir zwei weitere Event Listener, den OnItemClickListener und OnItemLongClickListener, kennenlernen und diese für unseren ListView registrieren.


Dazu werden wir zunächst im theoretischen Teil beschreiben wie in Android mit Hilfe dieser beiden Event Listener auf ListView-Eingaben reagiert wird und wie die Benutzer über die erfolgte Interaktion mit Hilfe von kurzen Einblendungen und einfachen Dialogen informiert werden.

Anschließend implementieren wir einen OnItemClickListener und registrieren diesen für den ListView unserer Android App. Der Listener wird die Zitat-Liste überwachen und dabei prüfen, ob ein Element der Liste angeklickt wurde. Immer wenn dies geschieht, wird er eine kurze Meldung, einen Toast, auf dem Display einblenden lassen und den Benutzer über den erfolgten Klick informieren.

Danach werden wir einen OnItemLongClickListener implementieren und auch diesen für den ListView registrieren. Mit diesem Listener reagieren wir auf Klicks, bei denen länger als eine halbe Sekunde auf ein Element des ListViews geklickt wurde. Erfolgt ein solcher langer Klick, lassen wir von dem Listener einen einfachen Dialog erstellen, welcher den Benutzer über das angeklickte Element informiert.

Abschließend werden wir unsere Android App im Emulator auf einem Android Virtual Device ausführen und die Funktionsweise der beiden neu registrierten Event Listener und des ListViews überprüfen.

1. Mit einem ListView auf Benutzereingaben reagieren

Um mit einem ListView auf Benutzereingaben reagieren zu können, müssen für diesen ganz bestimmte Event Listener registriert werden. In der vorherigen Lektion haben wir bereits den OnClickListener als Event Listener für Button-Objekte kennengelernt, mit dessen Hilfe effektiv auf Button-Klicks reagiert werden kann.

Möchte man Klicks auf einzelne Elemente eines ListViews erfassen, ist der OnClickListener hingegen nicht geeignet. Für solche Aufgaben stellt das Android Framework die beiden Event Listener-Interfaces OnItemClickListener und OnItemLongClickListener zur Verfügung.

Wir werden im Folgenden diese beiden Event Listener genauer betrachten. Zusätzlich stellen wir zwei Feedback-Arten vor, durch die der Nutzer über die erfassten Benutzereingaben informiert werden kann.

1.1 Die Event Listener OnItemClickListener und OnItemLongClickListener

Das Android Framework stellt die folgenden drei Event Listener-Interfaces für AdapterViews, zu denen auch die ListView-Klasse gehört, zur Verfügung:

  • OnItemClickListener – Dieses Interface enthält die Callback-Methode onItemClick(), die aufgerufen wird, wenn auf ein Element des ListViews kurz geklickt wurde.

  • OnItemLongClickListener – Dieses Interface enthält die Callback-Methode onItemLongClick(), die aufgerufen wird, wenn ein Element des ListViews angeklickt und gehalten wurde. Dabei muss der Klick länger als eine halbe Sekunde auf dem entsprechenden Element gehalten werden.

  • OnItemSelectedListener – Dieses Interface enthält die Callback-Methoden onItemSelected() und onNothingSelected(), die aufgerufen werden, wenn auf ein Element des ListViews ausgewählt wurde bzw. wenn das ausgewählte Element verschwindet, bspw. wenn der ListView geleert wird.

Wir werden uns in dieser Lektion mit den ersten beiden Event Listenern beschäftigen. Der dritte OnItemSelectedListener sei hier nur der Vollständigkeit halber genannt.

Quellcode-Beispiel eines OnItemClickListener

Um Klicks auf ListView-Elemente erfassen zu können, muss für den ListView eine OnItemClickListener-Instanz registriert werden. Damit dies möglich ist, muss das OnItemClickListener-Interface mit seiner Callback-Methode onItemClick() ausprogrammiert bzw. implementiert werden. In der onItemClick() Methode, die vom Android Framework automatisch beim Eintreten des Ereignisses aufgerufen wird, finden dann die eigentliche Ereignisbehandlung statt.

Das untere Beispiel zeigt, wie das OnItemClickListener-Interface implementiert und eine Instanz davon für ein ListView-Objekt registriert wird:

protected void onCreate(Bundle savedInstanceState) {
    ...

    // Instanziieren der anonymen Implementierung des OnItemClickListener-Interfaces
    AdapterView.OnItemClickListener onItemClickListener = new AdapterView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            // innerhalb dieser Methode kann auf den Item-Klick reagiert werden
            ...
        }
    };

    // Anfordern des ListView-Objekts über seine Ressourcen-ID
    ListView listview = (ListView) findViewById(R.id.listview_activity_main);

    // Registrieren der OnItemClickListener-Instanz für den ListView
    listview.setOnItemClickListener(onItemClickListener);

    ...
}

In den Zeilen 5 bis 11 wird mit Hilfe einer anonymen Klasse das OnItemClickListener-Interface implementiert. Da es in der AdapterView-Klasse definiert ist, wird mit AdapterView.OnItemClickListener darauf verwiesen. Auf diese Weise ist sofort ersichtlich, innerhalb welcher Klasse dieses Event Listener-Interface definiert ist. Von dem nun implementierten OnItemClickListener-Interface wird eine Instanz erzeugt und ihre Referenz in der Variable onItemClickListener gespeichert.

In Zeile 14 wird eine Referenz auf das ListView-Objekt mit Hilfe der findViewById() Methode angefordert und in der Variable listview gespeichert.

In Zeile 17 wird über dieses ListView-Objekt die setOnItemClickListener() Methode aufgerufen. Der Methode übergeben wir die weiter oben erzeugte OnItemClickListener-Instanz, wodurch der von uns implementierte OnItemClickListener für den ListView registriert wird.

Wird ein Element des ListViews angeklickt, erkennt dies das Android Framework und ruft die performItemClick() Methode des ListView-Objekts auf. In der performItemClick() Methode wird überprüft, ob eine OnItemClickListener-Instanz für das ListView-Objekt registriert wurde. Da dies jetzt der Fall ist, wird über das registrierte OnItemClickListener-Objekt dessen onItemClick() Methode aufgerufen, in der dann unsere eigene Ereignisbehandlung stattfinden wird.

Da wir erst das OnItemClickListener-Interface implementieren mussten, bevor wir eine OnItemClickListener-Instanz erzeugen konnten, ist sichergestellt, dass auch die onItemClick() Methode dieses Interfaces von uns ausprogrammiert wurde. Das Android System kann daher sicher sein, dass beim Aufruf der onItemClick() Methode per Callback das Ereignis ordnungsgemäß behandelt wird.

Quellcode-Beispiel eines OnItemLongClickListener

Um lange Klicks auf ListView-Elemente erfassen zu können, muss für den ListView eine OnItemLongClickListener-Instanz registriert werden. Damit dies möglich ist, muss das OnItemLongClickListener-Interface mit seiner Callback-Methode onItemLongClick() ausprogrammiert bzw. implementiert werden. In der onItemLongClick() Methode, die vom Android Framework automatisch beim Eintreten des Ereignisses aufgerufen wird, finden dann die eigentliche Ereignisbehandlung statt.

Das untere Beispiel zeigt, wie das OnItemLongClickListener-Interface implementiert und eine Instanz davon für ein ListView-Objekt registriert wird:

protected void onCreate(Bundle savedInstanceState) {
    ...

    // Instanziieren der anonymen Implementierung des OnItemLongClickListener-Interfaces
    AdapterView.OnItemLongClickListener onItemLongClickListener = new AdapterView.OnItemLongClickListener() {
        @Override
        public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
            // innerhalb dieser Methode kann auf den langen Item-Klick reagiert werden
            ...
        }
    };

    // Anfordern des ListView-Objekts über seine Ressourcen-ID
    ListView listview = (ListView) findViewById(R.id.listview_activity_main);

    // Registrieren der OnItemLongClickListener-Instanz für den ListView
    listview.setOnItemLongClickListener(onItemLongClickListener);   

    ...
}

In den Zeilen 5 bis 11 wird mit Hilfe einer anonymen Klasse das OnItemLongClickListener-Interface implementiert. Da es in der AdapterView-Klasse definiert ist, wird mit AdapterView.OnItemLongClickListener darauf verwiesen. Auf diese Weise ist sofort ersichtlich, innerhalb welcher Klasse dieses Event Listener-Interface definiert ist. Von dem nun implementierten OnItemLongClickListener-Interface wird eine Instanz erzeugt und ihre Referenz in der Variable onItemLongClickListener gespeichert.

In Zeile 14 wird eine Referenz auf das ListView-Objekt mit Hilfe der findViewById() Methode angefordert und in der Variable listview gespeichert.

In Zeile 17 wird über dieses ListView-Objekt die setOnItemLongClickListener() Methode aufgerufen. Der Methode übergeben wir die weiter oben erzeugte OnItemLongClickListener-Instanz, wodurch der von uns implementierte OnItemLongClickListener für den ListView registriert wird.

Wird ein Element des ListViews angeklickt, erkennt dies das Android Framework und ruft die performItemLongClick() Methode des ListView-Objekts auf. In der performItemLongClick() Methode wird überprüft, ob eine OnItemLongClickListener-Instanz für das ListView-Objekt registriert wurde. Da dies jetzt der Fall ist, wird über das registrierte OnItemLongClickListener-Objekt dessen onItemLongClick() Methode aufgerufen, in der dann unsere eigene Ereignisbehandlung stattfinden wird.

Die onItemLongClick() Methode liefert einen boolean-Wert als Rückgabewert an die aufrufende performItemLongClick() Methode zurück. Dies muss unbedingt beachtet werden. Wird als Wert true zurückgegeben, erkennt das Android Framework, dass der lange Klick von dem OnItemLongClickListener behandelt und verarbeitet wurde. Wird false zurückgegeben, wertet dies Android als unbehandeltes Eingabeereignis.

1.2 Kurze Meldungen mit Hilfe von Toasts ausgeben lassen

Mit einem Toast kann der Nutzer schnell und einfach über eine erfolgte Aktion informiert werden. Dem User wird dabei eine kleine Pop-Up Meldung für kurze Zeit eingeblendet. Während dieser Zeit bleibt die eigentliche Activity im Hintergrund dauerhaft sichtbar und wird nur überlagert.

Die eingeblendete Meldung nimmt nur so viel Platz auf dem Display in Anspruch wie sie unbedingt benötigt. Nach einigen Sekunden wird sie automatisch vom Android System ausgeblendet. Der Nutzer muss dafür keine Aktion ausführen.

Das untere Quellcode-Beispiel zeigt, wie ein Toast erzeugt und dem Nutzer eingeblendet wird:

protected void onCreate(Bundle savedInstanceState) {
    ...

    String message = "Ein Zitat wurde angeklickt.";
    int duration = Toast.LENGTH_LONG;

    Toast toast = Toast.makeText(getApplicationContext(), message, duration);
    toast.show(); 

    ...
}

In den Zeilen 4 und 5 werden zwei Variablen angelegt, in denen der Meldungstext und der Wert für die Anzeigedauer des Toasts gespeichert werden. Als Anzeigedauer kann zwischen den Konstanten LENGTH_SHORT (entspricht etwa 2 s) und LENGTH_LONG (entspricht etwa 3 s) der Toast-Klasse gewählt werden.

In Zeile 7 wird ein Toast-Objekt mit Hilfe der statischen Methode makeText() der Toast-Klasse instanziiert. Die makeText()-Methode übergeben wir als Argumente den App Context, den Meldungstext und die Anzeigedauer des Toast. Die Methode liefert ein vollständig erzeugtes Toast-Objekt als Rückgabewert zurück, dessen Referenz wir in der Variable toast speichern.

Mit der Methode show() in Zeile 8 lassen wir den Toast schließlich auf dem Android Gerät anzeigen. Das war auch schon alles. Wir werden den oberen Quellcode später wiederverwenden, wenn wir mit Hilfe eines Toasts den Nutzer über einen erfassten Klick auf ein ListView-Element informieren.

1.3 Über einen AlertDialog mit dem Nutzer kommunizieren

Neben Toasts können auch Dialoge für die Kommunikation mit dem Nutzer verwendet werden. Sie bieten im Gegensatz zu Toasts die Möglichkeit mit dem Benutzer zu interagieren, sprich die Antwort des Nutzers zu erfassen und entsprechend darauf zu reagieren.

In Android sind Dialog kleine Fenster, die dem User eingeblendet werden. Über sie werden dem Nutzer Informationen mitgeteilt und seine Reaktion darauf erfasst und ausgewertet. Dialoge nehmen nicht den gesamten Bildschirmplatz ein, sondern werden solange in den Vordergrund geschoben, bis der Nutzer eine bestimmte Aktion ausführt hat. Danach wird die App wieder normal weitergeführt.

Alle Dialoge in Android basieren auf der Dialog-Klasse. Diese Klasse sollte jedoch nicht direkt instanziiert werden, sondern stattdessen sollte eine ihrer Unterklassen bzw. Tochterklassen verwendet werden:

  • DatePickerDialog – Ein Dialog mit vordefiniertem Layout zur Eingabe eines Datums.
  • TimePickerDialog – Ein Dialog mit vordefiniertem Layout zur Eingabe einer Uhrzeit.
  • AlertDialog – Ein Dialog mit einem Titel, einem Meldungstext und bis zu drei Buttons. Es ist auch möglich eine Liste mit auswählbaren Einträgen im inneren des Dialogs anzuzeigen oder ein eigenes Layout zu verwenden.

Wir werden in unserer App einen AlertDialog verwenden und mit dessen Hilfe den Nutzer über einen erfassten langen Klick auf ein ListView-Element informieren. Dabei werden wir Informationen über das angeklickte ListView-Element von dem Dialog ausgeben lassen.

Das untere Quellcode-Beispiel zeigt, wie ein AlertDialog erzeugt und auf dem Android Gerät angezeigt wird:

protected void onCreate(Bundle savedInstanceState) {
    ...

    // 1. Instanziieren des AlertDialog.Builder mit dessen Konstruktor
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    
    // 2. Zusammenketten mehrerer Setter-Methoden zur Vorgabe der Dialog-Eigenschaften
    builder.setTitle("Der Titel des AlertDialogs")
           .setMessage("Der Meldungstext des AlertDialogs")
           .setPositiveButton("Schließen", null);

    // 3. Erhalten des AlertDialogs von der create() Methode und Anzeigen des Dialogs
    AlertDialog dialog = builder.create();
    dialog.show(); 

    ...
}

Für das Erzeugen eines AlertDialogs nutzt man am besten einen Builder, mit dessen Hilfe die Eigenschaften des Dialogs vorgegeben werden. In Zeile 5 wird ein solcher Builder instanziiert und ihm als Argument der Context übergeben. Als Context wird in diesem Fall die Referenz auf die Activity übergeben, von welcher der Dialog angezeigt werden soll.

Hinweis: Es ist wichtig dem Builder als Context die Referenz auf die Activity zu übergeben. Würde man als Context den Applictaion Context mit getApplicationContext() übergeben, würde daraus ein Absturz der Anwendung resultieren, da der Activity Context für das Anzeigen des AlertDialogs benötigt wird.

Anschließend werden in den Zeilen 8 bis 10 die Eigenschaften des AlertDialogs definiert. Dies wird vom Builder übernommen. Die einzelnen Setter-Methoden können aneinandergekettet werden, wodurch der Quellcode verständlicher und lesbarer wird.

Abschließend wird in Zeile 13 das AlertDialog-Objekt vom Builder mit Hilfe dessen create() Methode erzeugt. Der Dialog wird schließlich in Zeile 14 durch Aufrufen der show() Methode auf dem Display angezeigt. Dadurch rückt der angezeigte AlertDialog in den Fokus und überlagert die darunterliegende Activity.

Den oberen Quellcode werden wir später wiederverwenden, wenn wir mit Hilfe eines AlertDialogs den Nutzer über einen erfassten langen Klick auf ein ListView-Element informieren. Der AlertDialog wird dabei den Nutzer informieren, welches Zitat aus der Liste lange angeklickt wurde.

Wir haben nun den theoretischen Teil dieser Lektion abgeschlossen. In den nächsten beiden Abschnitten werden wir zwei ClickListener für den ListView unserer Android App registrieren. Beginnen werden wir mit einem OnItemClickListener, der prüft, ob ein ListView-Eintrag angeklickt wurde. Danach implementieren wir einen OnItemLongClickListener, mit dessen Hilfe wir lange Klicks auf die ListView-Einträge erfassen lassen.

2. Implementieren eines OnItemClickListener für den ListView

Dazu werden wir das AdapterView.OnItemClickListener-Interface mit Hilfe einer anonymen Klasse implementieren. Den dafür notwendigen Quellcode werden wir in der MainActivity-Klasse einfügen.

Wir öffnen nun die Klassendatei MainActivity.java im Editor von Android Studio. Dazu klicken wir doppelt auf ihren Dateinamen im Project Tool Window. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.zitate unseres Projekts.

In dem unteren Quellcode der MainActivity.java Datei sind die erforderlichen Maßnahmen bereits durchgeführt und die eingefügten Codezeilen markiert worden:

An dieser Stelle endet der freie Inhalt dieser Lektion. Wir hoffen, sie hat dir bis hierher gefallen! Du kannst sie im geschützten Bereich von ProgrammierenLernenHQ fortsetzen, in welchem sich alle Lektionen unserer Android Online-Kurse befinden.

Unsere Android Kurse bestehen aus insgesamt 43 großen Lektionen und sind unterteilt in 13 frei zugängliche und 30 Premium-Lektionen. Die Premium-Lektionen befinden sich in dem geschützten Bereich und sind nur für Käufer unserer Android Online-Kurse zugänglich.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813 An dieser Stelle endet der freie Inhalt dieser Lektion. Wir hoffen, sie hat dir bis hierher gefallen! Du kannst sie durch Kauf unseres Android Online-Kurs Gesamtpakets freischalten.

In unserem Android Online-Kurs Gesamtpaket befinden sich 43 große Lektionen, in denen wir dir schrittweise zeigen, wie voll funktionstüchtige Android Apps programmiert werden.

Diese Lektion ist Teil unserer Android Kurse. Insgesamt sind unsere Online-Kurse unterteilt in 13 frei zugängliche und 30 Premium-Lektionen.

Die Premium-Lektionen befinden sich in dem geschützten Bereich und sind nur für Käufer des Android Online-Kurs Gesamtpakets zugänglich.



Welche Inhalte befinden sich im Android Online-Kurs Gesamtpaket?

  • Das Gesamtpaket enthält alle Android Online-Kurse von ProgrammierenLernenHQ.
  • Im Paket enthalten ist unser großer Android Apps Programmieren Online-Kurs. Dieser besteht aus 35 großen Lektionen und ist als Einstiegskurs konzipiert worden. Die Grundlagen der Android App Entwicklung praxisnah und verständlich zu lehren, ist das Hauptziel des Android Apps Programmieren Kurses.
  • Im Paket enthalten ist auch unser SQLite Datenbank App Programmieren Online-Kurs. Dieser besteht aus 8 großen Lektionen und ist als weiterführender Kurs konzipiert worden. Der Kurs schließt an unseren Android Apps Programmieren Hauptkurs an und widmet sich dem speziellen Thema der SQLite Datenbanken.
  • Durch den Kauf erhältst du unbegrenzten Zugang zu all unseren Android Online-Kursen. Wir werden in Zukunft weitere Android Kurse hinzufügen. Auch auf alle zukünftigen Kurse erhältst du vollen Zugriff.

Wir hoffen, Dich bald als neuen Kursteilnehmer unserer Android Online-Kurse begrüßen zu dürfen!

Einmal kaufen und dadurch zeitlich unbegrenzten Zugriff auf alle Inhalte unserer Android Online-Kurse erhalten.



Hinweis: Der untere Quellcode ist Teil des geschützten Bereichs von ProgrammierenLernenHQ. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte.
Erfahre mehr über unsere Android Online-Kurse.

android_programmieren_lernen_blurry_sourcecode

Der obere Quellcode ist Teil des geschützten Bereichs. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte. Klicke auf die Info-Box, um mehr zu erfahren.

Im oberen Quellcode der MainActivity-Klasse wurden an mehreren Stellen Änderungen vorgenommen. Die eingefügten Zeilen sind grau markiert. Wir werden nun die durchgeführten Änderungen der Reihe nach besprechen.

In den Zeilen 8 und 12 werden die Klassen AdapterView und Toast mittels Import-Anweisungen innerhalb der MainActivity-Klasse sichtbar gemacht, so dass wir sie ohne den Namen ihres Packages verwenden können.

In Zeile 36 innerhalb der onCreate() Methode erfolgt der Aufruf der registerListViewClickListener() Methode. In dieser Methode werden wir ein OnItemClickListener-Objekt erzeugen und es für den ListView unserer App registrieren lassen. Die Definition der registerListViewClickListener() Methode erfolgt weiter unten im Quelltext.

Die registerListViewClickListener() Methode

Die registerListViewClickListener() Methode wird in der MainActivity-Klasse in den Zeilen 75 bis 90 definiert. Zu Übersichtlichkeit ist sie an dieser Stelle nochmals aufgeführt:

private void registerListViewClickListener() {

    AdapterView.OnItemClickListener onItemClickListener = new AdapterView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            int duration = Toast.LENGTH_LONG;
            String quoteAuthor = mQuoteList.get(position).getQuoteAuthor();
            String message = "Ein Zitat von " + quoteAuthor + " wurde angeklickt.";

            Toast toast = Toast.makeText(getApplicationContext(), message, duration);
            toast.show();
        }
    };

    mQuoteListView.setOnItemClickListener(onItemClickListener);
}

In den Zeilen 3 bis 13 der registerListViewClickListener() Methode wird das AdapterView.OnItemClickListener-Interface mit Hilfe einer anonymen Klasse implementiert. Dabei wird die onItemClick() Callback-Methode des Interfaces überschrieben.

In Zeile 6 wird die Anzeigedauer des Toasts in der Variable duration gespeichert. Als Wert wird die Konstante LENGTH_LONG festgelegt, welche etwa 3 s entspricht. In Zeile 7 wird der Autor des angeklickten Zitats ausgelesen und in der Variable quoteAuthor abgelegt. Welches Zitat, also welches ListView-Element, angeklickt wurde, ist in dem Methodenparameter position gespeichert. In Zeile 8 setzen wir den Meldungstext zusammen und speichern ihn in der Variable message.

In Zeile 10 lassen wir ein Toast-Objekt von der statischen Methode makeText() erzeugen. Der makeText() Methode übergeben wir als Argumente den Application Context, den Meldungstext und die Anzeigedauer des Toasts. Anstelle des Application Contexts hätte auch der Activity Context, mit MainActivity.this, übergeben werden können. Da Toasts aber anwendungsweit ausgegeben werden, ist hier der Application Context die bessere Wahl.

Nun ist der Toast erzeugt und mit Inhalt gefüllt. Er wird jedoch noch nicht ausgegeben. Die erfolgt erst in Zeile 11 durch Aufrufen der show() Methode auf der erzeugten Toast-Instanz.

In Zeile 15 registrieren wir für das ListView-Objekt den Event Listener, indem wir die OnItemClickListener-Instanz der setOnItemClickListener() Methode als Argument übergeben. Die OnItemClickListener-Instanz haben wir in Zeile 3 in der Variable onItemClickListener gespeichert.

Mit diesen Quellcodezeilen haben wir das OnItemClickListener-Interface implementiert, eine Instanz davon erzeugt und diese dem ListView als Event Listener zugewiesen. Wird von nun an auf ein ListView-Element geklickt, erfasst dies der registrierte OnItemClickListener und lässt einen Toast auf dem Display einblenden.

In Android Studio sollte der Inhalt der MainActivity.java Klassendatei nun wie folgt aussehen:

android_programmieren_lernen_blurry_sourcecode

Der obere Quellcode ist Teil des geschützten Bereichs. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte. Klicke auf die Info-Box, um mehr zu erfahren.

In der oberen Abbildung ist die überarbeitete MainActivity.java Klassendatei dargestellt. Der Quellcode wurde an drei Stellen erweitert. Welche Bedeutung der jeweilige Code-Block besitzt, ist in der unteren Liste angegeben:

  1. A – Die benötigten Import-Anweisungen zum Sichtbarmachen der Klassen AdapterView und Toast.
  2. B – Der Aufruf der registerListViewClickListener() Methode innerhalb der onCreate() Methode.
  3. C – Die Methode registerListViewClickListener(), in der ein OnItemClickListener implementiert und für den ListView registriert wird.

Wir haben nun einen OnItemClickListener für den ListView registriert. Unsere App ist nun in der Lage auf ListView-Klicks zu reagieren. Klickt der Benutzer auf ein ListView-Element, wird dies vom Android Framework erkannt und die Callback-Methode onItemClick() (über die performItemClick() Methode der AdapterView-Klasse von der sich unser ListView ableitet) aufgerufen. In der onItemClick() Methode behandeln wir den ListView-Klick, indem wir den Autor des angeklickten Zitats als Toast ausgeben lassen.

Wie dies zur Laufzeit auf einem Android Gerät aussieht, werden wir im nächsten Abschnitt erfahren, wenn wir unsere App ausführen lassen und auf einen ListView-Eintrag klicken.

2.1 Ausführen und Testen unserer Android App

Wir werden nun unserer Android App auf einem Android Virtual Device im Emulator ausführen lassen. Auf diese Weise können wir direkt überprüfen, wie unsere App reagiert, wenn ein ListView-Eintrag kurz angeklickt wird.

Unsere App starten wir dazu wie gewohnt über den Run > Run 'app' Menüeintrag, den wir über die obere Menüleiste erreichen.

Wird ein ListView-Element angeklickt, sieht das auf dem virtuellen Gerät nun wie folgt aus:

screenshot_onItemClickListener_3a

Wird ein ListView-Element kurz angeklickt, erscheint nun ein Toast (mittig am unteren Rand des Displays) der über den Autor des angeklickten Zitats informiert

In der oberen Abbildung ist der Startbildschirm, die Start-Activity, unserer App dargestellt. Wenn wir nun auf ein ListView-Element kurz klicken, wird dies vom OnItemClickListener erkannt und ein Toast eingeblendet. Der Toast wird im unteren Bereich des Displays dargestellt und informiert den Benutzer über den Autor des gerade angeklickten Zitats.

Wir haben nun einen OnItemClickListener implementiert und ihn für den ListView unserer App registriert. Als Nächstes werden wir das eben gelernte festigen und einen OnItemLongClickListener implementieren. Dieser soll den Benutzer mit Hilfe eines AlertDialogs über erfasste lange ListView-Klicks informieren.

3. Implementieren eines OnItemLongClickListener für den ListView

Wir werden nun einen OnItemLongClickListener für den ListView unserer Android App registrieren. Dazu werden wir wie im vorherigen Abschnitt zuerst das entsprechende Interface, AdapterView.OnItemLongClickListener, mit Hilfe einer anonymen Klasse implementieren.

Den dafür notwendigen Quellcode werden wir in der MainActivity-Klasse einfügen. Die Klassendatei sollte bereits im Editorfenster von Android Studio geöffnet sein.

In dem unteren Quellcode der MainActivity.java Datei sind die erforderlichen Maßnahmen bereits durchgeführt und die eingefügten Codezeilen markiert worden:

android_programmieren_lernen_blurry_sourcecode

Der obere Quellcode ist Teil des geschützten Bereichs. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte. Klicke auf die Info-Box, um mehr zu erfahren.

Im oberen Quellcode der MainActivity-Klasse wurden an mehreren Stellen Änderungen vorgenommen. Die eingefügten Zeilen sind grau markiert. Wir werden nun die durchgeführten Änderungen der Reihe nach besprechen.

In Zeile 4 wird die Klasse AlertDialog mittels Import-Anweisungen innerhalb der MainActivity-Klasse sichtbar gemacht, so dass wir sie ohne den Namen ihres Packages verwenden können.

In Zeile 38 innerhalb der onCreate() Methode erfolgt der Aufruf der registerListViewLongClickListener() Methode. In dieser Methode werden wir ein OnItemLongClickListener-Objekt erzeugen und es für den ListView unserer App registrieren lassen. Die Definition der registerListViewLongClickListener() Methode erfolgt weiter unten im Quelltext.

Die registerListViewLongClickListener() Methode

Die registerListViewLongClickListener() Methode wird in der MainActivity-Klasse in den Zeilen 94 bis 117 definiert. Zu Übersichtlichkeit ist sie an dieser Stelle nochmals aufgeführt:

private void registerListViewLongClickListener() {

    mQuoteListView.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
        @Override
        public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
            // 1. Instanziieren des AlertDialog.Builder mit dessen Konstruktor
            //    Als Context übergeben wir den Activity Context
            AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);

            // 2. Zusammenketten mehrerer Setter-Methoden zur Vorgabe der Dialog-Eigenschaften
            builder.setTitle(mQuoteList.get(position).getQuoteAuthor())
                    .setMessage(mQuoteList.get(position).getQuoteText())
                    .setPositiveButton("Schließen", null);

            // 3. Erhalten des AlertDialogs von der create() Methode und Anzeigen des Dialogs
            AlertDialog dialog = builder.create();
            dialog.show();

            // Der "Lange Klick" wurde von uns behandelt, daher geben wir als Wert true zurück
            return true;
        }
    });

}

In Zeile 3 wird eine Implementierung des OnItemLongClickListener für den ListView als Event Listener registriert. Dabei wird das OnItemLongClickListener-Interface mittels anonymer Klasse implementiert und direkt instanziiert. Die Referenz auf die erzeugte OnItemLongClickListener-Instanz wird der setOnItemLongClickListener() direkt übergeben, ohne sie wie im vorherigen Abschnitt in einer Variable zwischenzuspeichern.

Die Implementierung des OnItemLongClickListener-Interfaces besteht nur aus der onItemLongClick() Methode, die in den Zeilen 5 bis 21 definiert ist. In dieser Methode erzeugen wir zuerst, Zeile 8 ein AlertDialog.Builder-Objekt, welchem wir beim Instanziieren als Context den Activity Context übergeben. Dies ist wichtig, da der anzuzeigende Dialog über die Activity gelagert wird. Daher muss dem Builder auch der Context der Activity bekannt sein.

In Schritt zwei, Zeilen 11 bis 13, lassen wir den AlertDialog von dem Builder zusammensetzen. Dazu verketten wir mehrere Setter-Methoden miteinander. Der Dialog erhält als Titel den Authorennamen, als Text den Zitatinhalt und einen Schließen-Button für die Nutzerinteraktion.

Im dritten Schritt, Zeilen 16 und 17, lassen wir das AlertDialog-Objekt vom Builder erstellen und anschließend mit Hilfe der show() Methode anzeigen.

Mit diesen Quellcodezeilen haben wir das OnItemLongClickListener-Interface implementiert. Die Instanz des Listeners haben wir dem ListView direkt zugewiesen, ohne sie vorher in einer Variable zwischenzuspeichern. Wird von nun an auf ein ListView-Element lange geklickt, erfasst dies der registrierte OnItemLongClickListener und lässt einen AlertDialog über der Activity einblenden.

In Android Studio sollte der Inhalt der MainActivity.java Klassendatei nun wie folgt aussehen:

android_programmieren_lernen_blurry_sourcecode

Der obere Quellcode ist Teil des geschützten Bereichs. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte. Klicke auf die Info-Box, um mehr zu erfahren.

In der oberen Abbildung ist die überarbeitete MainActivity.java Klassendatei dargestellt. Der Quellcode wurde an drei Stellen erweitert. Welche Bedeutung der jeweilige Code-Block besitzt, ist in der unteren Liste angegeben:

  1. A – Die benötigten Import-Anweisungen zum Sichtbarmachen der Klasse AlertDialog.
  2. B – Der Aufruf der registerListViewLongClickListener() Methode innerhalb der onCreate() Methode.
  3. C – Die Methode registerListViewLongClickListener(), in der ein OnItemLongClickListener implementiert und für den ListView registriert wird.

Wir haben nun einen OnItemLongClickListener für den ListView registriert. Unsere App ist nun in der Lage auf kurze und lange ListView-Klicks entsprechend zu reagieren. Klickt der Benutzer lange auf ein ListView-Element, wird dies vom Android Framework erkannt und die Callback-Methode onItemLongClick() (über die performLongPress() Methode der AbsListView-Klasse von der sich unser ListView ableitet) aufgerufen. In der onItemLongClick() Methode behandeln wir den langen ListView-Klick, indem wir den Autor und Inhalt des angeklickten Zitats von einem AlertDialog ausgeben lassen.

Wie dies zur Laufzeit auf einem Android Gerät aussieht, werden wir im nächsten Abschnitt erfahren, wenn wir unsere App ausführen lassen und lange auf einen Eintrag des ListViews klicken.

4. Ausführen und Testen unserer Android App

Wir werden nun unserer Android App auf einem Android Virtual Device im Emulator ausführen lassen. Auf diese Weise können wir direkt überprüfen, wie unsere App reagiert, wenn ein ListView-Eintrag lang angeklickt wird.

Unsere App starten wir dazu wie gewohnt über den Run > Run 'app' Menüeintrag, den wir über die obere Menüleiste erreichen.

Wird ein ListView-Eintrag lange angeklickt, sieht das auf dem virtuellen Gerät nun wie folgt aus:

screenshot_onItemLongClickListener_3a

Wird ein Element des ListViews lange angeklickt, erscheint nun ein AlertDialog der über Autor und Inhalt des angeklickten Zitats informiert

In der oberen Abbildung ist der Startbildschirm, die Start-Activity, unserer App dargestellt. Wenn wir nun lange auf ein ListView-Element klicken, wird dies vom OnItemLongClickListener erkannt und ein AlertDialog eingeblendet. Der AlertDialog wird über der Activity ausgegeben und informiert den Benutzer über den Autor und Inhalt des gerade lange angeklickten Zitats.

Zusammenfassung

In dieser Lektion haben wir zwei weitere Event Listener, den OnItemClickListener und OnItemLongClickListener, des Ereignis-Behandlungs System von Android kennengelernt.

Dabei haben wir im theoretischen Teil erfahren wie in Android mit Hilfe dieser beiden Event Listener auf ListView-Eingaben reagiert wird und wie die Benutzer über die erfolgte Interaktion mit Hilfe von kurzen Einblendungen und einfachen Dialogen informiert werden können.

Im praktischen Teil der Lektion haben wir zuerst einen OnItemClickListener implementiert und diesen für den ListView unserer Android App registriert. Mit dem Listener lassen wir die Zitat-Liste überwachen und dabei prüfen, ob ein Listenelement angeklickt wurde. Erfolgt ein Klick, wird eine kurze Meldung, ein Toast, vom Listener auf dem Display eingeblendet, welche den Benutzer über den erfassten Klick informieren.

Danach haben wir einen OnItemLongClickListener implementiert und auch diesen für den ListView unserer Android App registriert. Mit diesem Listener lassen wir prüfen, ob ein ListView-Eintrag lange angeklickt wurde. Erfolgt ein solcher langer Klick, lassen wir von dem Listener einen AlertDialog erstellen, welcher den Benutzer über das angeklickte Element informiert.

Am Ende der Lektion haben wir unsere Android App im Emulator auf einem Android Virtual Device ausführen lassen und die Funktionsweise der beiden neu registrierten Event Listener und des ListViews überprüft.

Durch die Implementierung der Event Listener ist es nun möglich mit unserer Android App zu interagieren. In der nächsten Lektion werden wir eine weitere Interaktionsmöglichkeit unserer Anwendung hinzufügen. Dabei werden wir das Menü-System und die App Bar von Android näher kennenlernen.

Weiterführende Literatur




Schreibe einen Kommentar

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