android sqlite t6_wowomnom_Fotolia_85154667

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


In der sechsten Lektion unseres mehrteiligen Android SQLite Tutorials werden wir unserer Android Anwendung eine Contextual Action Bar hinzufügen und mit ihrer Hilfe Datensätze aus der SQLite Datenbank löschen.

Bevor wir Änderungen an den Dateien unseres SQLite Projekts vornehmen, werden wir uns kurz mit der Theorie beschäftigen. Dabei werden wir die folgenden beiden Fragen beantworten:

  • Wie werden Daten aus der SQLite Datenbank gelöscht?
  • Was ist die Contextual Action Bar (CAB) von Android?

Anschließend werden wir ein Menu Resource File für die Contextual Action Bar anlegen und zusätzlich eine String-Konstante in der strings.xml Ressourcen-Datei definieren.

Danach überarbeiten wir den Quellcode der ShoppingMemoDataSource-Klasse. Wir fügen ihr eine Lösch-Funktion hinzu, um Datensätze aus der SQLite Datenbank löschen zu können.

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:


Die Anweisung für das Löschen eines Datensatzes ist im oberen Quellcode gelb 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 geschlossen.

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.

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:


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 dem wir die Action Items definieren.

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 der String-Konstante für die Lösch-Aktion in der strings.xml Datei.
  2. Erstellen des Menu Resource Files und definieren des Action Items.

2.1 Anlegen der String-Konstante in der strings.xml Datei

Wir öffnen die strings.xml Ressourcendatei in Android Studio und fügen eine weitere String-Konstante mit folgender Zeile ein:


Im Editor von Android Studio sollte der Quellcode der strings.xml nun wie folgt aussehen:

android sqlite cab action strings

Eine weitere String-Konstante in der strings.xml Datei anlegen

Den eben angelegten String für die Lösch-Aktion werden wir nun im Menü der Contextual Action Bar wiederverwenden.

2.2 Erstellen des Menu Resource Files und definieren des Action Items

Jetzt werden wir ein Menu Resource File in Android Studio anlegen und darin das Menü für sie Contextual Action Bar mit unserem Action Item definieren. Dazu führen wir folgende Schritte aus:

  1. Wir klicken mit der rechten Maustaste auf den menu-Ordner. Es öffnet sich ein Kontextmenü.
  2. Jetzt klicken wir auf den oberen Menüeintrag New.
  3. Mit einem Klick auf Menu resource file lassen wir von Android Studio eine XML-Layout Menüdatei erstellen.
android sqlite cab menu resource file

Anlegen eines Menu Resource Files für die Contextual Action Bar

Als Nächstes öffnet sich der Dialog New Menu Resource File.

Wir geben in das Textfeld als Namen für die XML-Menü Datei menu_contextual_action_bar ein und bestätigen mit dem OK-Button.

android sqlite cab menu create

Den Namen des Menu Resource Files festlegen

Jetzt wird von Android Studio die Menü Ressourcen-Datei erstellt und in den res\menu-Verzeichnis abgelegt. Als Nächstes werden wir unseren Action Item als Menüeintrag in der XML-Datei definieren.

Wir möchten in der eben erstellten Menü Ressourcen-Datei folgende Anpassungen vornehmen:

  • Einfügen eines Menüeintrags (menu item).
  • Dem Menüeintrag die ID cab_delete zuweisen.
  • Ein Symbol (Mülleimer) für den Menüeintrag festlegen.
  • Dem Menüeintrag den Title cab_delete aus der String Ressourcen-Datei zuweisen.

Der folgende Quellcode setzt die oben beschriebenen Anpassungen um:


Den oberen Quellcode fügen wir in die menu_contextual_action_bar.xml Datei ein und haben somit unser Menü für die Contextual Action Bar definiert.

In Android Studio sieht dies dann folgendermaßen aus:

android sqlite cab menu

Definieren des Action Items für das Menü der Contextual Action Bar

Wir haben jetzt ein XML-Layout 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 die Methode deleteShoppingMemo() in die Klasse ShoppingMemoDataSource einfügen. Import-Anweisungen werden wir dafür nicht benötigen.

Am Ende dieses Abschnitts haben wir nochmals den kompletten Quellcode der ShoppingMemoDataSource-Klasse aufgeführt. Ihr könnt ihr ihn zur Kontrolle bzw. Orientierung nutzen.

3.1 Die Methode deleteShoppingMemo() definieren

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:


Die ID des zu löschenden Datensatzes lesen wir aus dem übergebenen ShoppingMemo-Objekt mit der Anweisung in Zeile 1 aus. Anschließend führen wir die Lösch-Operation auf dem SQLiteDatabase-Objekt aus.

Zu Testzwecken geben wir die ID und den Inhalt des gelöschten Datensatzes in einer Log-Meldung aus.

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 dem unten angegebenen Quellcode ist die gesamte ShoppingMemoDataSource-Klasse zur Kontrolle für euch aufgeführt. Die neu eingefügten Zeilen sind gelb markiert.

Der vollständiger Quelltext der Klasse ShoppingMemoDataSource:


In Android Studio sieht die Klasse ShoppingMemoDataSource nun wie folgt aus:

android sqlite delete datasource

Die überarbeitete Klasse ShoppingMemoDataSource mit Markierungen

In der oberen Abbildung ist die neue Methode deleteShoppingMemo() mit einem blauen Rahmen markiert. Durch sie können wir nun Datensätze aus der SQLite Datenbank entfernen lassen.

Diese neue Methode werden wir im nächsten Abschnitt nutzen und erstmals Datensätze aus unsere SQLite Datenbank löschen. Dazu werden wir die Contextual Action Bar nutzen und über ihren Action Item (Lösch-Aktion) Einträge aus dem ListView und gleichzeitig 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 Klasse 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.

Am Ende dieses Abschnitts haben wir nochmals den kompletten Quellcode der MainActivity-Klasse aufgeführt. Falls ihr bei den folgenden drei Schritten durcheinander kommt, könnt ihr ihn zur Kontrolle bzw. Orientierung nutzen.

Nun beginnen wir mit dem ersten Arbeitsschritt.

4.1 Einfügen der Import-Anweisungen

Wir öffnen als Erstes die Klassendatei MainActivity.java im Editorfenster von Android Studio über einen Klick auf den entsprechenden Eintrag in der linken Projektleiste.

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


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 besteht nun aus folgenden Quellcode:


Der Aufruf der initializeContextualActionBar() Methode aus Zeile 10 ist neu hinzugekommen. Die Methode ist noch nicht definiert. Dies werden wir nun im nächsten Arbeitsschritt nachholen.

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.

Wir fügen den folgenden Quellcode in den Methodenbereich der MainActivity-Klasse ein:


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

Mit den Zeilen 6 bis 52 implementieren wir den MultiChoiceModeListener und registrieren ihn 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.

Damit können wir dann prüfen, welche Listeneinträge tatsächlich ausgewählt wurden und diese dann mit der Anweisung in Zeile 36 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 (entsprechen den 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 gelb markiert.

Der vollständiger Quelltext der Klasse MainActivity:


In Android Studio sollte die Klasse MainActivity nun wie folgt aussehen:

android sqlite cab mainactivity

Die überarbeitete Klasse MainActivity mit Markierungen

In der oberen Abbildung sind die in den drei Arbeitsschritten vorgenommenen Änderungen mit einem blauen Rahmen markiert.

Die Import-Anweisungen sind mit A markiert. Die Änderung an der onCreate() Methode der MainActivity ist mit einem B markiert. Die Methode initializeContextualActionBar(), mit der wir den MultiChoiceModeListener für den ListView registrieren und die Contextual Action Bar initialisieren, ist mit einem C markiert.

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

In diesem Abschnitt werden wir unsere Android App ausführen und überprüfen, ob Einträge über die Contextual Action Bar aus der SQLite Datenbank gelöscht werden können.

Dazu werden wir zunächst die Anwendung auf einem Android Gerät ausführen und anschließend die zurückgelieferten Log-Meldungen in Android Studio analysieren. Zusätzlich prüfen wir auch, ob die Einträge korrekt aus dem ListView der MainActivity entfernt werden.

5.1 Ausführen der Android SQLite-App

Nun wollen wir unsere App ausführen und testen. Dazu installieren wir die Anwendung auf unser angeschlossenes Android Gerät (Smartphone oder Tablet) oder in einer AVD des Android Emulators.

Wie eine Android App installiert wird, könnt ihr in den folgenden beiden Teilen unseres großen Android App Programmieren Tutorials nachlesen:

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 sqlite app starten

Android App über das Run App-Symbol starten

Nach einigen Momenten öffnet sich der Choose Device-Dialog. In ihm nehmen wir die folgenden Einstellungen vor:

  1. Radio Button Choose a running device aktivieren
  2. Das angeschlossene Android Gerät auswählen
  3. Mit einem Klick auf den OK-Button die Installation unserer App auf das Gerät starten
android choose device

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.

5.2 Überprüfen der Log-Meldungen in Android Studio

Unsere SQLite-App sollte jetzt auf dem Android Gerät gestartet worden sein.

Um die Log-Meldungen zu überprüfen, öffnen wir in Android Studio die Android-Ansicht bei angeschlossenem Android Gerät.

In der unteren Abbildung sind die Log-Meldungen direkt nach dem Starten unserer Android App dargestellt. Der in Lektion 2 angelegte Log-Filter ist aktiviert (rote Markierung X). Unsere Meldungen werden im logcat-Textbereich angezeigt.

android sqlite cab log

Überprüfen der Log-Meldungen in Android Studio mit aktivem Log-Filter – Unsere SQLite-App wurde gestartet

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 und Schließen der App dargestellt. Die Log-Meldungen werden im logcat-Textbereich angezeigt. Die Meldungen, die über den Löschvorgang informieren, sind von einem blauen Rahmen (Markierung 1) umschlossen.

android sqlite cab log delete

Überprüfen der Log-Meldungen in Android Studio mit aktivem Log-Filter – 2 Einträge wurden gelöscht und die App beendet

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/data/de.programmierenlernenhq.shoppinglisthq/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 der unteren Abbildung 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 delete

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

Ein Video veranschaulicht den Löschvorgang mit der Contextual Action Bar aber viel besser als ein Bild. Daher haben wir eine kleine Funktionspräsentation unserer SQLite App in Form eines Videos erstellt.

5.3 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 abhaken könnten. Diese Funktion werden wir in der nächsten Lektion unserer Android App hinzufügen.


Comments 4

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

  2. Christoph

    Hey,

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

    Grüße

    1. Post
      Author
      Chris

      Hallo Christoph,

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

      Viele Grüße, Chris

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

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *