android sqlite t6_wowomnom_Fotolia_85154667

Android SQLite Datenbank Tutorial – Teil 6: Datensätze aus der SQLite Datenbank löschen


Die größten Änderungen am Quellcode werden wir dann an der MainActivity-Klasse vornehmen. In ihr initialisieren wir die Contextual Action Bar und registrieren einen Listener für den ListView, der auf lange Klicks reagiert. Über die Contextual Action Bar wird es dann möglich sein Einträge aus der SQLite Datenbank zu löschen.

Abschließend werden wir unsere SQLite App auf einem Android Smartphone installieren und testen. Dabei werden wir mehrere Datensätze gleichzeitig mit Hilfe der Contextual Action Bar aus der SQLite Datenbank entfernen.

Nun wünschen wir euch viel Spaß bei Teil 6 unseres Android SQLite Datenbank Tutorials. Los geht’s!

1. Daten aus unserer SQLite Datenbank mit Hilfe der Contextual Action Bar löschen

In Android ist das Löschen von Datensätzen aus einer SQLite Datenbank sehr leicht zu realisieren. Wenn eine Verbindung zur Datenbank besteht, können mit der Methode delete() Datensätze direkt aus der Tabelle der Datenbank entfernt werden.

Um eine Lösch-Operation in einer Android App anzuweisen, wird meist mit einem Kontextmenü gearbeitet. Wir werden in dieser Lektion die Contextual Action Bar dazu verwenden. Sie ist eine moderne Version des klassischen Kontextmenüs und viel intuitiver zu bedienen.

1.1 Daten aus der SQLite Datenbank löschen

Wenn eine Verbindung zur SQLite Datenbank besteht, also eine Referenz auf ein SQLiteDatabase-Objekt existiert, kann über die SQLiteDatabase-Instanz die Methode delete() aufgerufen werden.

Der delete() Methode muss der Tabellenname und das Suchkriterium, welches meist die ID des zu löschenden Datensatzes ist, übergeben werden. In unserer SQLite App werden wir die Lösch-Operation in der Datenquelle ausführen. Sie besitzt die Verbindung zur Datenbank und führt alle Datenbankzugriffe aus.

Mit folgender Methode werden wir später Datensätze aus der SQLite Datenbank löschen:

public void deleteShoppingMemo(ShoppingMemo shoppingMemo) {
    long id = shoppingMemo.getId();

    database.delete(ShoppingMemoDbHelper.TABLE_SHOPPING_LIST,
                    ShoppingMemoDbHelper.COLUMN_ID + "=" + id,
                    null);

    Log.d(LOG_TAG, "Eintrag gelöscht! ID: " + id + " Inhalt: " + shoppingMemo.toString());
}

Die Anweisung für das Löschen eines Datensatzes ist im oberen Quellcode markiert worden. Die delete() Methode wird auf dem SQLiteDatabase-Objekt aufgerufen. Als Argumente wird ihr der Name unserer Tabelle und der Such-String mit der ID des zu löschenden Datensatzes übergeben. Das dritte Argument wird in diesem Fall nicht benötigt und ist null.

Mit dieser einfachen Anweisung können wir Daten aus der SQLite Datenbank löschen. Um einen Löschvorgang anzuweisen, werden wir die Contextual Action Bar von Android nutzen, die wir im nächsten Unterabschnitt näher kennenlernen werden.

1.2 Was ist die Contextual Action Bar?

Die Contextual Action Bar (CAB) ist eine temporäre Action Bar, die für eine gewisse Zeit über die normale Action Bar der App gelegt wird. Sobald die Aufgabe, für welche die Contextual Action Bar eingeblendet wurde, abgeschlossen ist, wird sie wieder ausgeblendet.

Die Contextual Action Bar erscheint, wenn der Benutzer lange auf ein View-Element klickt und dadurch den selection mode auslöst. Die Contextual Action Bar muss dem View-Element aber vorher zugewiesen worden sein. Dies geschieht, indem an einen MultiChoiceModeListener für das View-Element registriert.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

Hat der User ein Element durch langes Klicken ausgewählt und die Contextual Action Bar dadurch aktiviert, kann er:

  • Weitere Elemente auswählen, indem er sie anklickt.
  • Eine Aktion ausführen lassen, die auf alle ausgewählten Elemente angewendet wird.
  • Die Contextual Action Bar wieder schließen, indem er den Back-Button klickt.

Eine Contextual Action Bar sollte immer dann verwendet werden, wenn der User Elemente durch langes Anklicken auswählen kann. Sie ist ab Android 3.0 (API level 11) verfügbar. Soll die App auch frühere Android Version unterstützen, muss das normale Kontextmenü stattdessen verwendet werden.

1.3 Die Contextual Action Bar einem ListView zuweisen

Möchte man die Contextual Action Bar einem ListView zuweisen und sollen mehrere Einträge auswählbar sein, müssen die folgenden zwei Schritte ausgeführt werden:

  • ChoiceMode setzen – Der ChoiceMode muss mit setChoiceMode() auf CHOICE_MODE_MULTIPLE_MODAL gesetzt werden, damit mehrere Elemente ausgewählt werden können.
  • Implementieren des Listeners – Das AbsListView.MultiChoiceModeListener-Interface muss implementiert und mit setMultiChoiceModeListener() für den ListView registriert werden. Mit den Callback-Methoden des Interfaces können die Aktionen der Contextual Action Bar definiert und auf Klicks reagiert werden.

Der Quellcode würde dann wie folgt aussehen:

final ListView shoppingMemosListView = (ListView) findViewById(R.id.listview_shopping_memos);
shoppingMemosListView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE_MODAL);

shoppingMemosListView.setMultiChoiceModeListener(new AbsListView.MultiChoiceModeListener() {

    @Override
    public void onItemCheckedStateChanged(ActionMode mode, int position, 
                                          long id, boolean checked) {
        // Hier können wir auf das Auswählen von Einträgen reagieren und den Text in 
        // der CAB daran anpassen, bspw. Anzahl der ausgewählten Einträge aktualisieren.
        // Von hier kann ein mode.invalidate() angefordert werden.
    }

    @Override
    public boolean onCreateActionMode(ActionMode mode, Menu menu) {
        // Das Menü der CAB mit Actions füllen.
        getMenuInflater().inflate(R.menu.menu_contextual_action_bar, menu);
        return true;
    }

    @Override
    public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
        // Hier können wir Updates an der CAB vornehmen, indem wir auf
        // eine invalidate() Anfrage reagieren.
        return false;
    }

    @Override
    public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
        // Hier können wir auf Klicks auf CAB-Actions reagieren.
        switch (item.getItemId()) {
            case R.id.cab_delete:
                deleteSelectedItems(); // Einträge löschen
                mode.finish();         // und CAB schließen.
                return true;
            default:
                return false;
        }
    }

    @Override
    public void onDestroyActionMode(ActionMode mode) {
        // Hier können wir Aktualisierungen an der Activity vornehmen, wenn die CAB
        // entfernt wird. Standardmäßig werden die ausgewählten Einträge wieder freigegeben.
    }
});

Mit diesem Quellcode werden die beiden oben beschriebenen Schritte ausgeführt und die Contextual Action Bar für den ListView registriert.

Wenn nun der Benutzer einen Listeneintrag mit einem langen Klick auswählt, ruft das Android System die Callback-Methode onCreateActionMode() auf und zeigt die Contextual Action Bar mit den vorgegebenen Actions an.

Solange die Contextual Action Bar sichtbar ist, kann der Benutzer weitere Einträge auswählen und die verfügbaren Aktionen darauf ausführen lassen.

Weiterführende Informationen über die Contextual Action Bar könnt ihr hier finden:

2. Ein Menü für die Contextual Action Bar anlegen

Die Contextual Action Bar haben wir jetzt etwas näher kennengelernt. Es ist nun an der Zeit sie in unsere SQLite App zu integrieren. Dazu müssen wir als Erstes ein Menu Resource File erstellen, in welchem wir die Action Items definieren.

Die zu erstellende Menu-Datei muss in dem res/menu/ Ressourcen-Ordner abgelegt werden. Dieses Verzeichnis existiert momentan noch nicht in unserem Android Projekt und muss daher von uns erstellt werden.

Die Action Items sind die Aktionen, die über die Contextual Action Bar ausführbar sein sollen. Bei unserer Android App wird dies zunächst die Lösch-Aktion sein.

In einer späteren Lektion werden wir noch eine Eintrag-Ändern-Aktion hinzufügen. Aber im Moment wird die Contextual Action Bar nur eine Aktion (Löschen) bereitstellen.

Um den Action Item in die Contextual Action Bar einzufügen, werden wir folgende Arbeitsschritte ausführen:

  1. Anlegen des menu-Ordners – Wir legen in dem Ressourcen-Ordner unseres Android Studio Projekts den menu-Ordner an. In ihm werden alle zukünftigen XML-Menü Dateien abgelegt.
  2. Erstellen der XML-Menü Datei – In dem erstellten menu-Ordner lassen wir von Android Studio eine neue XML-Menü Datei mit dem Dateinamen menu_contextual_action_bar.xml erstellen. Anschließend definieren wir in der erstellten Menü Datei den Action Item per Android XML-Vokabular.

Beginnen wir nun mit dem ersten Arbeitsschritt.

2.1 Anlegen des menu-Ordners in Android Studio

Alle XML-Menü Dateien müssen in dem menu-Ordner des Android Projekts abgelegt werden. Beim Kompilieren wird die lokale Ressourcen-Klasse R generiert, welche die Ressourcen-IDs für alle Ressourcen innerhalb des gesamten res/ Verzeichnisses enthält.

Wir werden nun den menu-Ordner anlegen. Dazu gehen wir folgendermaßen vor:

  1. Mit der rechten Maustaste auf den Ordner res/ in dem Project Tool Window klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Directory klicken.
android_sqlite_cab_menu_folder

Erstellen des Menu-Ordners in Android Studio

Anschließend öffnet sich der New Directory-Dialog, in welchem wir den Namen des zu erstellenden Ordner vorgeben werden:

android_sqlite_cab_menu_folder_name

Im New Directory-Dialog geben wir den Namen für den menu-Ordner vor

Wir tragen in das Feld Enter new directory name den Wert menu ein und bestätigen anschließend den Dialog mit einem Klick auf den OK Button.

Nun legt Android Studio den Ressourcen-Ordner menu/ für unsere XML-Menü Dateien automatisch an.

2.2 Erstellen des Menu Resource Files und definieren des Action Items

Als nächsten Schritt erstellen wir die XML-Menü Datei menu_contextual_action_bar.xml, mit welcher wir das Menü für die Contextual Action Bar mit unserem Action Item definieren. Dazu führen wir die folgenden Schritte aus:

  1. Zunächst mit der rechten Maustaste auf den eben erstellten menu/ Ordner klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Und schließlich auf Menu resource file klicken.
android_sqlite_cab_menu_file

Erstellen des Menu Resource File menu_contextual_action_bar.xml für die Start-Activity unserer App

Anschließend öffnet sich der New Menu Resource File-Dialog, der uns bei der Erstellung der XML-Ressourcen Datei unterstützt.

In dem New Menu Resource File-Dialog geben wir menu_contextual_action_bar.xml als Namen für die XML-Menü Datei ein:

android_sqlite_cab_menu_file_name

Den Namen des Menu Resource Files festlegen

Anschließend bestätigen wir den New Menu Resource File-Dialog mit einem Klick auf den OK Button, woraufhin die neue XML-Ressourcen Datei automatisch von Android Studio erstellt und im Editorfenster der IDE geöffnet wird.

Falls die Datei nicht automatisch geöffnet wurde, führen wir das Öffnen manuell durch. Dazu klicken wir doppelt auf ihren Dateinamen menu_contextual_action_bar.xml im Project Tool Window von Android Studio. Die Datei befindet sich im res/menu/ Ordner unseres Projekts.

Standardmäßig öffnet sich das Editorfenster in der Design-Ansicht. Damit der XML-Code der Menü Datei angezeigt wird, müssen wir unten im Editorfenster den Tab Text anklicken.

In der erstellten Menü Ressourcen-Datei definieren wir nun das Menü der Contextual Action Bar. Dazu löschen wir den generierten XML-Code vollständig und fügen an dessen Stelle den folgenden XML-Code ein:

menu_contextual_action_bar.xml

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">

    <item
        android:id="@+id/cab_delete"
        android:icon="@android:drawable/ic_menu_delete"
        android:title="@string/cab_delete" />

</menu>

Mit dem oberen Code haben wir das Menü der Contextual Action Bar definiert.

Das Menü besteht aus einem einzigen Menüeintrag (item), für welchen wir mit @+id/cab_delete eine eigene ID angelegt haben. Weiterhin haben wir als Symbol für den Menüeintrag einen Mülleimer festgelegt.

In Zeile 7 greifen wir auf die String-Ressource @string/cab_delete zu und verwenden diese als Titel des Löschen-Menüeintrags.

In Android Studio sollte die menu_contextual_action_bar.xml Datei nun wie folgt aussehen:

android_sqlite_cab_menu_file_code

Die XML-Menü Datei menu_contextual_action_bar.xml mit den vorgenommenen Änderungen

Wir haben jetzt ein XML-Menü für die Contextual Action Bar in Android erstellt. Dabei greifen wir auch auf die Ressourcen-Datei strings.xml zurück und lesen aus ihr die Bezeichnung für unseren Menüeintrag (Lösch-Aktion) aus.

Die Contextual Action Bar werden wir später in Abschnitt 4 in der MainActivity-Klasse initialisieren. Doch vorher werden wir eine Methode zum Löschen von Datensätzen aus der SQLite Datenbank erstellen. Die neue Methode werden wir in unserer Datenquelle der ShoppingMemoDataSource-Klasse definieren.

3. Die deleteShoppingMemo() Methode in unserer Datenquelle ShoppingMemoDataSource anlegen

Das Löschen von Datensätzen werden wir von unserer Datenquelle ausführen lassen. Dazu werden wir nun die Methode deleteShoppingMemo() in die Klasse ShoppingMemoDataSource einfügen. Import-Anweisungen werden wir dafür nicht benötigen.

Hinweis: Wir werden jetzt die Arbeitsschritte der Reihe nach ausführen. Sollte etwas unklar sein, könnt ihr im Anschluss daran den gesamten Quellcode der ShoppingMemoDataSource-Klasse in Ruhe analysieren und direkt erkennen, an welcher Stelle welcher Code-Block eingefügt werden muss.

3.1 Die Methode deleteShoppingMemo() definieren

Wir öffnen nun die Klassendatei ShoppingMemoDataSource.java in dem Editor von Android Studio. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.shoppinglist unseres Projekts.

Wir fügen nun den folgenden Quellcode in den Methodenbereich der ShoppingMemoDataSource-Klasse direkt nach der createShoppingMemo() Methode ein:

ShoppingMemoDataSource.java

public void deleteShoppingMemo(ShoppingMemo shoppingMemo) {
    long id = shoppingMemo.getId();

    database.delete(ShoppingMemoDbHelper.TABLE_SHOPPING_LIST,
                    ShoppingMemoDbHelper.COLUMN_ID + "=" + id,
                    null);

    Log.d(LOG_TAG, "Eintrag gelöscht! ID: " + id + " Inhalt: " + shoppingMemo.toString());
}

Die ID des zu löschenden Datensatzes lesen wir aus dem übergebenen ShoppingMemo-Objekt mit der Anweisung in Zeile 2 aus.

Anschließend führen wir die Lösch-Operation in den Zeilen 4 bis 6 auf dem SQLiteDatabase-Objekt aus, indem wir die delete() Methode nutzen und von dieser den zur ID passenden Datensatz aus der Datenbank entfernen lassen.

In Zeile 8 lassen wir zu Testzwecken die ID und den Inhalt des gelöschten Datensatzes in einer Log-Meldung auf der Konsole ausgeben.

3.2 Der komplette Quellcode der ShoppingMemoDataSource-Klasse

Nun haben wir die neue Methode deleteShoppingMemo() in der ShoppingMemoDataSource-Klasse definiert und das Löschen von Datensätzen aus der Tabelle der Android SQLite Datenbank vorbereitet.

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

android_sqlite_cab_data_source

Die Klassendatei ShoppingMemoDataSource.java mit den vorgenommenen Änderungen

In der oberen Abbildung ist die ShoppingMemoDataSource.java Klassendatei dargestellt. Es ist nur die hinzugefügte Methode deleteShoppingMemo() aufgeklappt. Alle anderen Methoden sind unverändert geblieben und daher zugeklappt. Die hinzugefügten Codezeilen sind zudem mit Markierungen versehen worden.

Durch neue Methode deleteShoppingMemo() (Markierung A) können wir nun Datensätze aus der SQLite Datenbank entfernen lassen. Wir werden sie bereits im nächsten Abschnitt nutzen und erstmals Datensätze aus unsere SQLite Datenbank löschen. Dafür werden wir die Contextual Action Bar verwenden und über deren Action Item (Lösch-Aktion) mehrere Einträge aus dem ListView und somit auch aus der SQLite Datenbank löschen.

4. Die Contextual Action Bar in der MainActivity initialisieren

Nun werden wir die Contextual Action Bar in der MainActivity-Klasse initialisieren. Dazu werden wir die MainActivity um eine neue Methode erweitern. Mit Hilfe der Contextual Action Bar wird es möglich sein, Datensätze aus der SQLite Datenbank zu löschen.

Um dies zu realisieren, nehmen wir die folgenden drei Änderungen am Quellcode der MainActivity vor:

  1. Einfügen der Import-Anweisungen – Zuerst importieren wir die benötigten Klassen.
  2. Überarbeiten der onCreate() Methode – Hier werden wir die neue Methode initializeContextualActionBar() aufrufen.
  3. Definieren der initializeContextualActionBar() Methode – In dieser Methode registrieren wir einen MultiChoiceModeListener für den ListView. Mit dem Listener erfassen wir lange Klicks und implementieren die Callback-Methoden der Contextual Action Bar.

Hinweis: Wir werden jetzt die Arbeitsschritte der Reihe nach ausführen. Sollte etwas unklar sein, könnt ihr im Anschluss daran den gesamten Quellcode der MainActivity-Klasse in Ruhe analysieren und direkt erkennen, an welcher Stelle welcher Code-Block eingefügt werden muss.


Nun beginnen wir mit dem ersten Arbeitsschritt.

4.1 Einfügen der Import-Anweisungen

Wir öffnen nun die Klassendatei MainActivity.java in dem Editor von Android Studio. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.shoppinglist unseres Projekts.

Anschließend fügen wir den folgenden Quellcode unter den bereits vorhandenen Import-Anweisungen ein:

MainActivity.java

import android.util.SparseBooleanArray;
import android.view.ActionMode;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.AbsListView;

Die fünf Klassen bzw. Interfaces machen wir mittels Import-Anweisungen innerhalb der Klasse MainActivity sichtbar, so dass wir sie ohne den Namen ihres Packages verwenden können.

Die Klasse SparseBooleanArray benötigen wir für das Arbeiten mit den Elementen unseres ListViews. Die Klassen ActionMode und AbsListView sowie die Interfaces Menu und MenuItem werden für das Implementieren der Contextual Action Bar benötigt.

4.2 Überarbeiten der onCreate() Methode der MainActivity-Klasse

Im zweiten Arbeitsschritt überarbeiten wir die onCreate() Methode unserer MainActivity-Klasse. Wir werden von der onCreate() Methode aus die neue Methode initializeContextualActionBar() aufrufen.

Die onCreate() Methode der MainActivity.java besteht nun aus folgendem Quellcode:

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.

MainActivity.java

android_sqlite_table_mainactivity_blurry

In Zeile 10 wird die initializeContextualActionBar() Methode, durch die unsere Contextual Action Bar initialisiert wird, aufgerufen. Da die Methode noch nicht von uns definiert wurde, wird sie im Editorfenster noch in roter Schrift angezeigt. Wir werden sie im nächsten Arbeitsschritt definieren und damit das Problem beheben.

4.3 Definieren der initializeContextualActionBar() Methode

Kommen wir nun zum wichtigsten Arbeitsschritt dieser Lektion des Android SQLite Tutorials. Wir werden nun eine neue Methode definieren, mit der wir die Contextual Action Bar initialisieren und mit deren Hilfe es möglich sein wird Datensätze aus der SQLite Datenbank zu löschen.

Wie eine Contextual Action Bar initialisiert wird, haben wir bereits weiter oben im theoretischen Teil besprochen. Jetzt ist es an der Zeit dies in die Praxis umzusetzen.

Wir fügen nun den folgenden Quellcode in den Methodenbereich der MainActivity.java Klasse direkt nach der activateAddButton() Methode ein:

MainActivity.java

private void initializeContextualActionBar() {
  final ListView shoppingMemosListView = (ListView) findViewById(R.id.listview_shopping_memos);
  shoppingMemosListView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE_MODAL);

  shoppingMemosListView.setMultiChoiceModeListener(new AbsListView.MultiChoiceModeListener() {

    @Override
    public void onItemCheckedStateChanged(ActionMode mode, int position, long id, boolean checked) {

    }

    @Override
    public boolean onCreateActionMode(ActionMode mode, Menu menu) {
      getMenuInflater().inflate(R.menu.menu_contextual_action_bar, menu);
      return true;
    }

    @Override
    public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
      return false;
    }

    @Override
    public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
      switch (item.getItemId()) {

        case R.id.cab_delete:
          SparseBooleanArray touchedShoppingMemosPositions = shoppingMemosListView.getCheckedItemPositions();
          for (int i=0; i < touchedShoppingMemosPositions.size(); i++) {
            boolean isChecked = touchedShoppingMemosPositions.valueAt(i);
            if(isChecked) {
              int postitionInListView = touchedShoppingMemosPositions.keyAt(i);
              ShoppingMemo shoppingMemo = (ShoppingMemo) shoppingMemosListView.getItemAtPosition(postitionInListView);
              Log.d(LOG_TAG, "Position im ListView: " + postitionInListView + " Inhalt: " + shoppingMemo.toString());
              dataSource.deleteShoppingMemo(shoppingMemo);
            }
          }
          showAllListEntries();
          mode.finish();
          return true;

        default:
          return false;
      }
    }

    @Override
    public void onDestroyActionMode(ActionMode mode) {

    }
  });

}

Mit der Anweisung in Zeile 2 fragen wir eine Referenz zu dem ListView-Objekt der MainActivity an. Anschließend setzen wir in Zeile 3 den ChoiceMode auf CHOICE_MODE_MULTIPLE_MODAL, wodurch mehrere Listeneinträge ausgewählt werden können.

Mit den Zeilen 5 bis 51 implementieren wir den MultiChoiceModeListener und registrieren diesen für das ListView-Objekt. Die Callback-Methoden des MultiChoiceModeListener haben wir bereits weiter oben im theoretischen Teil dieser Lektion besprochen.

Momentan sind für uns nur die beiden Callbacks onCreateActionMode() und onActionItemClicked() relevant. Mit der Methode onCreateActionMode() füllen wir das Menü der Contextual Action Bar mit unserem Action Item, der Lösch-Aktion.

Die Methode onActionItemClicked() ist etwas umfangreicher. Mit ihr prüfen wir welcher Action Item angeklickt wurde und führen dann die entsprechenden Aktionen aus. In unserem Fall prüfen wir, ob der Action Item mit der ID cab_delete angeklickt wurde. Wenn das der Fall war, lassen wir uns die Positionen aller berührten Listeneinträge geben.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

Damit können wir dann prüfen, welche Listeneinträge tatsächlich ausgewählt wurden und diese dann mit der Anweisung in Zeile 35 aus der SQLite Datenbank löschen. Anschließend aktualisieren wir den ListView und schließen die Contextual Action Bar.

4.4 Der komplette Quellcode der MainActivity-Klasse

Nun haben wir alle Änderungen an der MainActivity-Klasse vorgenommen. Mit dem eingefügtem Quellcode reagieren wir auf lange Klicks des Benutzers und löschen die ausgewählten Listeneinträge zusammen mit den zugehörigen Datensätzen aus der SQLite Datenbank.

In dem unten angegebenen Quellcode ist die gesamte MainActivity-Klasse zur Kontrolle für euch aufgeführt. Die neu eingefügten Zeilen sind markiert worden.

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

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_sqlite_lektion6_blurry

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

In der oberen Abbildung ist die MainActivity.java Klassendatei dargestellt. Es sind nur die Methoden onCreate() und initializeContextualActionBar() aufgeklappt. Alle anderen Methoden sind unverändert geblieben und daher zugeklappt. Die hinzugefügten Codezeilen sind zudem mit Markierungen versehen worden.

Welche Bedeutung der jeweilige Code-Block besitzt, ist in der unteren Liste angegeben:

  1. A – Die benötigten Import-Anweisungen zum Sichtbarmachen der Klassen bzw. Interfaces SparseBooleanArray, ActionMode, Menu, MenuItem und AbsListView.
  2. B – Die onCreate() Methode wurde leicht überarbeitet. Ihr wurde der initializeContextualActionBar() Methodenaufruf hinzugefügt.
  3. C – Die Methode initializeContextualActionBar(), mit der wir den MultiChoiceModeListener für den ListView registrieren und die Contextual Action Bar initialisieren.

Mit diesen Änderungen im Quellcode der MainActivity-Klasse haben wir unsere SQLite App um eine sehr nützliche Funktion erweitert. Wir können jetzt Datensätze aus der SQLite Datenbank unter Zuhilfenahme der Datenquelle löschen.

Im nächsten Abschnitt werden wird die Contextual Action Bar unserer SQLite App testen und erstmals Einträge aus Einkaufsliste und somit auch aus der hinterlegten SQLite Datenbank löschen.

5. Starten und Testen unserer SQLite App

Wir werden nun unserer Android App auf einem Android Virtual Device im Emulator ausführen lassen und überprüfen, ob Einträge über die Contextual Action Bar aus der SQLite Datenbank gelöscht werden können.

Hinweis: Wenn ihr Probleme beim Ausführen der App im Android Emulator oder auf einem Android Gerät haben solltet, könnt ihr unseren großen Android Apps Programmieren Kurs als Hilfe nutzen. Darin zeigen wir, wie eine Android App im Emulator oder auf einem physikalischen Android Gerät ausgeführt wird.

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

Unsere SQLite App sollte jetzt auf dem Android Gerät gestartet worden sein. Die grafische Benutzeroberfläche der Anwendung hat sich auch diesmal nicht geändert, daher sieht auf dem Gerät alles genau so aus wie in der vorherigen Lektion.

Hinweis: Das Emulator-Fenster mit dem darin laufenden Android Virtual Device muss für die nächsten Arbeitsschritte geöffnet bleiben. Zudem muss in dem AVD unsere eigene App ausgeführt werden. Sollte dies nicht der Fall sein, muss die App erneut im Emulator gestartet werden.

Um die Log-Meldungen zu überprüfen, öffnen wir in Android Studio das Logcat Tool Window während unsere App auf dem AVD im Emulator ausgeführt wird.

Dazu führen wir die folgenden Schritte aus:

  1. Wir öffnen das Logcat Tool Window mit einem Klick auf den Logcat-Tab am unteren Bildschirmrand.
  2. Anschließend wählen wir Emulator Nexus_9 als AVD in der Drop-Down Liste aus.
  3. Nun wählen wir unsere App de.codeyourapp.shoppinglist in der Liste rechts daneben aus.
  4. Danach stellen wir die Prioritätsstufe auf Verbose ein.
  5. Und geben in das anschließende Suchfeld MainActivity|ShoppingMemo als Suchbegriff ein.
  6. Dann wählen wir den Eintrag Show only selected application in Liste ganz rechts aus.
android_sqlite_cab_logcat_start

Überprüfen der Log-Meldungen unserer App im Logcat Tool Window von Android Studio

Nun klicken wir lange auf den dritten Listeneintrag 1 x Banane, wodurch die Contextual Action Bar über die normale Action Bar gelegt wird. Wir wählen auch den vierten Eintrag 2 x Birnen aus. Anschließend klicken wir auf das Mülleimer-Symbol oben rechts in der Contextual Action Bar und veranlassen dadurch das Löschen der beiden ausgewählten Einträge aus der SQLite Datenbank.

In der unteren Abbildung sind die Log-Meldungen nach dem Löschen der beiden Einträge (Markierung A) und Schließen der App dargestellt:

android_sqlite_cab_logcat_end

Es wurden zwei Einträge aus dem ListView und somit auch aus der Datenbank entfernt

Uns werden die folgenden Log-Meldungen ausgegeben:

01: MainActivity﹕ Das Datenquellen-Objekt wird angelegt.
02: ShoppingMemoDataSource﹕ Unsere DataSource erzeugt jetzt den dbHelper.
03: ShoppingMemoDbHelper﹕ DbHelper hat die Datenbank: shopping_list.db erzeugt.
04: MainActivity﹕ Die Datenquelle wird geöffnet.
05: ShoppingMemoDataSource﹕ Eine Referenz auf die Datenbank wird jetzt angefragt.
06: ShoppingMemoDataSource﹕ Datenbank-Referenz erhalten. Pfad zur Datenbank: /data/user/0/de.codeyourapp.shoppinglist/databases/shopping_list.db
07: MainActivity﹕ Folgende Einträge sind in der Datenbank vorhanden:
08: ShoppingMemoDataSource﹕ ID: 1, Inhalt: 5 x Äpfel
09: ShoppingMemoDataSource﹕ ID: 2, Inhalt: 3 x Saft
10: ShoppingMemoDataSource﹕ ID: 3, Inhalt: 1 x Banane
11: ShoppingMemoDataSource﹕ ID: 4, Inhalt: 2 x Birnen
12: ShoppingMemoDataSource﹕ ID: 5, Inhalt: 3 x Kartoffeln
13: MainActivity﹕ Position im ListView: 2 Inhalt: 1 x Banane
14: ShoppingMemoDataSource﹕ Eintrag gelöscht! ID: 3 Inhalt: 1 x Banane
15: MainActivity﹕ Position im ListView: 3 Inhalt: 2 x Birnen
16: ShoppingMemoDataSource﹕ Eintrag gelöscht! ID: 4 Inhalt: 2 x Birnen
17: ShoppingMemoDataSource﹕ ID: 1, Inhalt: 5 x Äpfel
18: ShoppingMemoDataSource﹕ ID: 2, Inhalt: 3 x Saft
19: ShoppingMemoDataSource﹕ ID: 5, Inhalt: 3 x Kartoffeln
20: MainActivity﹕ Die Datenquelle wird geschlossen.
21: ShoppingMemoDataSource﹕ Datenbank mit Hilfe des DbHelpers geschlossen.

Die meisten Log-Meldungen sind bereits bekannt. Neu sind die Meldungen 13 bis 19, die über die gelöschten Datenbankeinträge informieren und den aktuellen Inhalt der SQLite Datenbank ausgeben.

In dem unteren animierten GIF ist das Vorgehen für das Löschen von Datensätzen aus unserer SQLite Datenbank mit Hilfe der Contextual Action Bar noch einmal dargestellt:

android_sqlite_cab_demo

Einträge aus der SQLite Datenbank mit Hilfe der Contextual Action Bar löschen

5.1 Video – Funktionspräsentation unserer SQLite App

In dem unteren Video haben wir zwei Einträge aus dem ListView und somit auch aus der SQLite Datenbank gelöscht. Im Video ist zu sehen, wie das Löschen mit Hilfe der Contextual Action Bar funktioniert.

Mit dieser neuen Funktion kann die Einkaufslisten-App jetzt auch endlich in der Praxis eingesetzt werden. Unsere SQLite App ist zwar noch nicht vollständig, aber bereits für den ersten Einkauf nutzbar.

In den nächsten Lektionen unseres Android SQLite Datenbank Tutorials werden wir die App um weitere Funktionen erweitern, bspw. dem Ändern und Abhaken von Einträgen. Aber für den Moment sind wir zufrieden mit dem Erreichten und können die selbst programmiere Android App für den nächsten Einkauf nutzen.

Zusammenfassung

In dieser Lektion unseres SQLite Tutorials haben wir gelernt, wie Daten aus der SQLite Datenbank mit Hilfe der Contextual Action Bar gelöscht werden.

Zu Beginn der Lektion haben wir im theoretischen Teil den SQL-Befehl delete kennengelernt und kurz die Contextual Action Bar von Android behandelt. Wir werden die Contextual Action Bar in späteren Lektionen wiederverwenden, da sie sich ideal für unsere Zwecke nutzen lässt.

Anschließend haben wir ein Menü für die Contextual Action Bar erstellt und darin einen Action Item (Löschen) definiert. Danach haben wir unsere Datenquelle, die Klasse ShoppingMemoDataSource, um eine Methode zum Löschen der Datensätze erweitert.

Die größte Änderung haben wir dann an der MainActivity-Klasse vorgenommen und in ihr die Contextual Action Bar mit der neuen Methode initializeContextualActionBar() initialisiert. Abschließend haben wir unsere SQLite App getestet und dabei erstmals Datensätze aus der Tabelle unserer SQLite Datenbank gelöscht.

Unsere selbst programmierte SQLite App kann jetzt schon eingesetzt werden. Wir können Werte in die Einkaufsliste eintragen, diese anzeigen lassen und wieder löschen. Es wäre aber sehr hilfreich für unsere Nutzer, wenn sie Einträge auch ändern könnten. Diese Funktion werden wir in der nächsten Lektion unserer Android App hinzufügen.



Comments 12

  1. „Die ID des zu löschenden Datensatzes lesen wir aus dem übergebenen ShoppingMemo-Objekt mit der Anweisung in Zeile 1 aus.“

    *Zeile 2

    1. Post
      Author
  2. „Jetzt öffnen wir die Klassendatei ShoppingMemoDataSource.java im Editorfenster von Android Studio über einen Klick auf den entsprechenden Eintrag in der linken Projektleiste und fügen wir den folgenden Quellcode in den Methodenbereich der ShoppingMemoDataSource-Klasse ein:“

    * Das „wir“ nach dem „fügen“ ist zu viel oder? 😉

    1. Post
      Author

      Hallo Daniel,

      danke für den Hinweis! Ich habe die entsprechende Stelle korrigiert.

      Viele Grüße, Chris

  3. Hi Chris,

    erst einmal wieder ein super Tutorial.

    Eine Frage:
    Ist (R.id.listview_shopping_memos) ein von dir erwählter Name oder ist das so in Android?
    Kann ich auch schreiben: (R.id.listview_PLACEHOLDER_PLACEHOLDER)?

    Wenn ja, wo muss ich das überall ändern? Bei mir hat es keine Referenz, wenn ich nicht (R.id.listview_shopping_memos) angebe.

    Danke für deine Antwort.

    1. Post
      Author

      Hallo Daniel,

      den Namen listview_shopping_memos habe ich vorher festgelegt. Über den Namen kann ich auf die ID des ListViews R.id.listview_shopping_memos zugreifen und somit auf das ListView-Objekt selbst findViewById(R.id.listview_shopping_memos).

      Dieser Name wurde von mir bei der Definition des ListViews in der entsprechenden XML-Layout Ressourcendatei activity_main.xml festgelegt.

      Viele Grüße, Chris

  4. Hallo Chris,

    mir ist nicht ganz bewusst für was der SparseBooleanArray steht und was er macht. Wäre echt nett, wenn du es ein bisschen näher erläutern könntest. Ich bedanke mich im Voraus.

    Liebe Grüße,
    Bertan

  5. Pingback: Android SQLite Tutorial - Teil 1: SQLite Projekt anlegen

  6. Hey,

    ich hoffe du findest mal wieder ein wenig Zeit dieses Tutorial weiter zu führen.

    Grüße

    1. Post
      Author

      Hallo Christoph,

      der nächste Teil wird gerade erstellt und wird höchstwahrscheinlich diese Woche noch veröffentlicht.

      Viele Grüße, Chris

  7. Pingback: Android SQLite Tutorial - Teil 2: SQLite Datenbank integrieren

Schreibe einen Kommentar

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