android sqlite introT7_wowomnom_Fotolia_85154667

Android SQLite Datenbank Tutorial – Teil 7: Datensätze in der SQLite Datenbank ändern


In der siebten Lektion unseres mehrteiligen Android SQLite Tutorials werden wir unserer Android App eine weitere Funktion hinzufügen.

Mit der neuen Funktion sollen Datensätze in der SQLite Datenbank geändert werden können. Das Ändern wird über die Contextual Action Bar ausgelöst und die geänderten Daten werden mit Hilfe eines eingeblendeten Dialogs erfasst.

Um dies zu realisieren, werden wir die folgenden Arbeitsschritte durchführen:

  1. Anlegen der benötigten String-Konstanten in der strings.xml Ressourcen-Datei.
  2. Definieren eines weiteren Action Items in der Menü-Datei der Contextual Action Bar.
  3. Erstellen der Layout-Datei für den eingeblendeten EditShoppingMemo-Dialog.
  4. Erweitern unserer Datenquelle (DataSource) um die updateShoppingMemo() Methode.
  5. Erweitern der Callback-Methoden der Contextual Action Bar in der MainActivity-Klasse.

Anschließend werden wir unsere SQLite App ausführen und testen. Wir werden Datensätze in der Tabelle der SQLite Datenbank ändern und dabei auch wieder die Log-Meldungen unserer Anwendung analysieren.

Bevor wir jedoch mit dem Programmieren beginnen, werden wir uns im theoretischen Teil dieser Android Lektion intensiver mit der Contextual Action Bar beschäftigen und Dialoge in Android kennenlernen.

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

1. Daten in der SQLite Datenbank mit Hilfe der Contextual Action Bar ändern

In diesem Abschnitt werden wir den SQL-Befehl update(), der für das Ändern von Datensätzen verantwortlich ist, näher kennenlernen.

Zusätzlich werden wir auf die Callback-Methoden der Contextual Action Bar detailliert eingehen. Dabei erfahren wir welche Callback-Methode wofür benötigt wird.

Die Contextual Action Bar haben wir bereits in der vorherigen Lektion kennengelernt und in unsere SQLite App integriert.

1.1 Daten in der SQLite Datenbank ändern

Das Ändern von Datensätzen in einer SQLite Datenbank ist sehr einfach. Die neuen Daten werden ContentValues zwischengespeichert und dann mit der Methode update() in die SQLite Datenbank eingetragen.

Folgender Quellcode stellt dies beispielhaft dar:


In den Zeilen 1 bis 3 bereiten wir die geänderten Werte für das Eintragen in die SQLite Datenbank vor. Dazu erzeugen wir ein ContentValues-Objekt und fügen die neuen Werte für das Produkt und die Anzahl darin ein.

Das Eintragen übernimmt die put() Methode, der wir jeweils ein Schlüssel-Wert Paar (Key-Value-Pair) übergeben. Der Schlüssel muss dabei dem Name der entsprechenden Spalte unserer Tabelle entsprechen.

Anschließend aktualisieren wir die Werte des entsprechenden Datensatzes mit Hilfe der update() Methode, die wir auf dem SQLiteDatabase-Objekt aufrufen. Sie erwartet als Argumente den Namen der Tabelle, das ContentValues-Objekt und das Suchkriterium, in unserem Fall der Datensatz mit der bestimmten ID. Das letzte Argument wird nicht benötigt und ist daher null.

Wie in den vorherigen Lektionen schon mehrfach erwähnt, werden alle Zugriffe auf die SQLite Datenbank von unserer Datenquelle verwaltet. Daher werden wir die oberen Quellcode-Zeilen später in der neuen Methode updateShoppingMemo() der ShoppingMemoDataSource-Klasse wiederverwenden.

1.2 Die Callbacks der Contextual Action Bar

Die Contextual Action Bar haben wir bereits in der vorherigen Lektion kennengelernt. Um sie zu initialisieren, müssen die folgenden fünf Callback-Methoden implementiert werden:

  • onItemCheckedStateChanged() – Wird aufgerufen, wenn ein Listeneintrag aus- oder abgewählt wird. Hier zählen wir die ausgewählten Einträge mit und fordern mode.invalidate() an, um die Contextual Action Bar anzupassen.
  • onCreateActionMode() – Wird aufgerufen, wenn der Action Mode erzeugt wird. Hier füllen wir das Menü der Contextual Action Bar mit Action Items.
  • onPrepareActionMode() – Wird immer dann aufgerufen, wenn der Action Mode gezeigt wird. Wird immer nach onCreateActionMode() aufgerufen und kann auch mehrfach aufgerufen werden, z.B. wenn der Action Mode ungültig geworden ist. Hier reagieren wir auf die invalidate() Anfrage und passen die Contextual Action Bar entsprechend den Erfordernissen an.
  • onActionItemClicked() – Wird aufgerufen, wenn der User einen Menüeintrag der Contextual Action Bar angeklickt hat. Hier reagieren wir auf Klicks auf die Menüeinträge.
  • onDestroyActionMode() – Wird aufgerufen, wenn der User den Action Mode verlässt. Hier setzen wir den Zähler, der anzeigt wie viele Einträge ausgewählt sind, wieder zurück.

Der folgende Quellcode enthält die fünf Callback-Methoden der Contextual Action Bar mit kurzen Erläuterungen:


Um mit Hilfe der Contextual Action Bar Datensätze in der SQLite Datenbank ändern zu können, werden wir an vier der fünf Callback-Methoden Änderungen vornehmen. Im oberen Quellcode haben wir in den Kommentaren kurz beschrieben, was wir in dem jeweiligen Callback durchführen werden.

Was wir in den Callbacks genau machen, werden wir in einem späteren Abschnitt dieser Lektion noch detailliert beschreiben. Im Moment ist es aber ausreichend zu wissen, dass es die Callback-Methoden gibt und was ihre Funktion ist.

Falls ihr tiefer in das spannende Android Thema Contextual Action Bar eintauchen möchtet, könnt ihr hier weitere Informationen darüber finden:

2. Einen AlertDialog in Android erstellen

Ein Dialog ist ein kleines Fenster, welches dem Benutzer eingeblendet wird, um eine Entscheidung zu treffen oder zusätzliche Informationen einzugeben.

Dialoge füllen meist den Bildschirm des Android Geräts nicht vollständig aus. Der User muss meist mit Hilfe eines Dialogs eine Aktion ausführen, bevor die Anwendung fortgesetzt werden kann.

Die Klasse Dialog ist die Basisklasse für Dialoge, sie sollte jedoch nicht instanziiert werden. Stattdessen sollte mit einer ihrer Subklassen gearbeitet werden.

In Android werden folgende Dialog-Subklassen oft verwendet:

  • AlertDialog – Mit dieser Klasse kann ein Dialog mit einem Titel, bis zu drei Buttons, einer Liste oder auch einem eigenes Layout dargestellt werden. Wir werden für unsere SQLite App einen AlertDialog erzeugen.
  • DatePickerDialog – Mit dieser Klasse kann ein vordefinierter Dialog zur Datumswahl angezeigt werden.
  • TimePickerDialog – Mit dieser Klasse kann ein vordefinierter Dialog zur Zeitauswahl angezeigt werden.

Diese Klassen definieren das Aussehen und den Aufbau für den eigenen Dialog. Sie sollten jedoch nicht direkt verwendet werden, sondern zusätzlich in einem DialogFragment eingebettet werden. Über die DialogFragment-Klasse kann das Dialog-Objekt erstellt und angepasst werden.

Dieses Vorgehen hat den Vorteil, dass die Lifecycle Events, wie Pressen des Back-Buttons oder Rotieren des Bildschirms, korrekt behandelt werden. Außerdem kann mit Hilfe der DialogFragment-Klasse die UI des Dialogs als eingebettete Komponente auf Android Geräten mit hohen Auflösungen wiederverwendet werden.

Aus diesen Gründen ist es sehr empfehlenswert die DialogFragment-Klasse zu benutzen und den Dialog darin einzubetten. Wir werden dies in diesem SQLite Tutorial jedoch nicht tun, sondern direkt mit der AlertDialog-Klasse arbeiten. Wir tun dies, damit unser Android Projekt nicht zu groß und komplex wird.

Wie wir später sehen werden, wird unsere Lösung wie erwartet funktionieren. Das Verwenden der DialogFragment-Klasse wäre aber die sauberere Lösung.

2.1 Wie wird ein AlertDialog in Android erstellt?

Mit der AlertDialog-Klasse können viele verschiedene Dialog-Designs nachgebildet werden. Die Dialoge werden mit dem AlertDialog.Builder zusammengebaut und bestehen immer aus drei Bereichen.

Ein AlertDialog besteht aus den folgenden drei Bereichen:

  1. Titel-Bereich – Der oberste Bereich ist für den Titel des Dialogs vorgesehen. Dieser Bereich ist optional und sollte nur wenn nötig verwendet werden, bspw. über einer Liste oder einem eigenen Layout.
  2. Inhalt-Bereich – Der mittlere Bereich enthält den Inhalt des Dialogs. Hier kann eine Nachricht, eine Liste oder ein komplettes Layout mit verschiedenen Widget-Elementen angezeigt werden.
  3. Action Button-Bereich – Im unteren Bereich befinden sich immer die Buttons. Neben einem positiven (Agree) und negativen (Cancel) Button kann auch ein neutraler (Remind me later) Button angezeigt werden.

Mit der AlertDialog.Builder-Klasse können diese Bereiche erstellt werden. Diese Klasse stellt die API zur Verfügung und ermöglicht einen bequemen und schnellen Zusammenbau von Dialogen.

Um einen kompletten AlertDialog zu erzeugen, geht man wie folgt vor:


2.2 Einem AlertDialog Buttons hinzufügen

In Android können einem Dialog mit Hilfe des AlertDialog.Builders sehr einfach Buttons hinzugefügt werden. Für die eingefügten Buttons können auch direkt Listener registriert werden.

Um Buttons in einem Dialog einzufügen, geht man folgendermaßen vor:


Mit den drei Methoden setPositiveButton(), setNegativeButton() und setNeutralButton() werden die Buttons für positives, negatives und neutrales Feedback erstellt. Sie erwarten als Argumente den Button-Titel als String und einen DialogInterface.OnClickListener mit dem auf Klicks reagiert werden kann.

Die verschiedenen Button Arten sollten wie folgt eingesetzt werden:

  • Positive Button – Mit ihm sollte die geplante Aktion fortgesetzt werden oder vorgenommene Eingabe akzeptiert werden.
  • Negative Button – Mit ihm sollte die geplante Aktion abgebrochen werden.
  • Neutral Button – Mit ihm sollte die geplante Aktion weder abgebrochen noch fortgesetzt werden, sondern nur auf eventuell später verschoben. Ein bekanntest Beispiel hierfür ist der Remind me later. Button.

Einem AlertDialog kann nur ein Button jeder Button-Art zugewiesen werden. Es kann somit keine zwei Positive Buttons in einem Dialog geben.

Wir werden unserem AlertDialog einen positiven und einen negativen Button hinzufügen. Einen neutralen Dialog werden wir nicht benötigen.

2.3 Einem AlertDialog ein eigenes Layout zuweisen

Mit unserem AlertDialog sollen Änderungen an einem Datensatz der SQLite Datenbank vorgenommen werden können.

Dazu müssen wir die Eingaben der User erfassen können und benötigen somit ein eigenes Layout mit zwei EditText-Feldern.

Zum Glück haben die Entwickler von Android schon an einen solchen Fall gedacht und mit der Methode setView() das passende Werkzeug für uns zur Verfügung gestellt.

Um einen Dialog mit einem eigenen Layout zu erstellen wird wieder der AlertDialog.Builder benötigt, auf dessen Instanz die Methode setView() aufgerufen werden muss. Als Argument muss ein View-Objekt übergeben werden.

Das View-Objekt können wir nach unseren Vorstellungen erstellen. Alles was wir dafür benötigen ist eine Layout-Ressourcen Datei, in der wir das gewünschte Layout des Dialogs definieren.

Um einen AlertDialog ein eigenes Layout zuzuweisen, geht man wie folgt vor:


Standardmäßig füllt das so zugewiesene Layout das Dialogfenster aus. Es können zudem weitere Elemente, wie ein Titel oder Buttons, dem AlertDialog mit dem Hilfe der Setter-Methoden des AlertDialog.Builders zugewiesen werden.

Wie das Erstellen und Nutzen eines AlertDialogs in der Praxis funktioniert, werden wir später in Abschnitt 7 erfahren. Möchtet ihr dieses interessante Thema besser kennenlernen, solltet ihr euch folgende Links einmal in Ruhe ansehen:

3. Anlegen der String-Konstanten in der strings.xml Datei

Da wir die Theorie jetzt abgeschlossen haben, können wir mit der Arbeit an unserem Android SQLite Projekt beginnen.

Wir öffnen nun die strings.xml Ressourcendatei in Android Studio und fügen sieben weitere String-Konstanten mit den folgenden Zeile ein:


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

android sqlite strings xml

Weitere String-Konstanten in der strings.xml Datei anlegen

Die eben angelegten String-Konstanten werden wir für die Eintrag Ändern-Aktion im Menü der Contextual Action Bar und im AlertDialog wiederverwenden. Als Nächstes werden wir einen zweiten Menüeintrag für unsere Contextual Action Bar definieren.

4. Action Item für die Contextual Action Bar definieren

Jetzt werden wir einen weiteren Action Item als Menüeintrag in der menu_contextual_action_bar.xml Datei definieren.

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

  • Einfügen eines Menüeintrags (menu item).
  • Dem Menüeintrag die ID cab_change zuweisen.
  • Ein Symbol (Stift) für den Menüeintrag festlegen.
  • Dem Menüeintrag den Title cab_change 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 oberhalb des bisherigen Menüeintrags ein und haben somit unser Menü für die Contextual Action Bar um einen zusätzlichen Eintrag erweitert.

In Android Studio sieht dies dann folgendermaßen aus:

android sqlite cab menu

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

Wir haben jetzt einen zweiten Action Item in der XML-Layout für die Contextual Action Bar definiert. Dabei greifen wir auch auf die Ressourcen-Datei strings.xml zurück und lesen aus ihr die Bezeichnung für unseren Menüeintrag (Ändern-Aktion) aus.

Als Nächstes werden wir das Layout für den AlertDialog definieren und dazu eine neue Layout-Datei erstellen.

5. Erstellen einer Layout-Datei für den AlertDialog

Jetzt werden wir ein Layout Resource File in Android Studio anlegen und darin das Layout für den AlertDialog definieren. Dazu führen wir folgende Schritte aus:

  • Wir klicken mit der rechten Maustaste auf den layout-Ordner. Es öffnet sich ein Kontextmenü.
  • Jetzt klicken wir auf den oberen Menüeintrag New.
  • Mit einem Klick auf Layout resource file lassen wir von Android Studio eine XML-Layout Datei erstellen.
android sqlite alertdialog layout

Anlegen eines Layout Resource Files für den AlertDialog

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

Wir geben in das Textfeld als File name für die XML-Layout Datei dialog_edit_shopping_memo ein und als Root element legen wir LinearLayout fest. Anschließend bestätigen wir die Eingaben mit dem OK-Button.

android sqlite alertdialog filename

Den Namen des Layout Resource Files festlegen

Jetzt wird von Android Studio die Layout Ressourcen-Datei erstellt und in den res\layout-Verzeichnis abgelegt. Als Nächstes werden wir das Layout unseres AlertDialogs in der XML-Datei definieren.

Dazu fügen wir den folgenden Quellcode in die Layout-Datei dialog_edit_shopping_memo.xml ein:


Mit den oberen Quellcode haben wir das Layout für unseren AlertDialog definiert. Aus der Layout-Datei werden wir später ein View-Objekt erzeugen und dieses dann dem AlertDialog mit der Methode setView() zuweisen.

Das erstellte Layout wird den mittleren Bereich des AlertDialogs ausfüllen und besteht aus zwei TextView- und EditText-Feldern. Über die EditText-Felder werden die User in unserer SQLite App die Änderungen an einem Listeneintrag vornehmen können.

In Android Studio sollte die neue Layout-Datei nun wie folgt aussehen:

android sqlite alertdialog definieren

Definieren des Layouts für den AlertDialog

Wir haben jetzt ein XML-Layout für den AlertDialog erstellt. Dabei greifen wir auch auf die Ressourcen-Datei strings.xml zurück und lesen aus ihr die Bezeichnungen für die beiden TextViews aus.

Den AlertDialog werden wir später in Abschnitt 7 in der MainActivity-Klasse initialisieren. Doch vorher werden wir eine Methode zum Ändern von Datensätzen in der SQLite Datenbank erstellen. Die neue Methode werden wir in unserer Datenquelle der ShoppingMemoDataSource-Klasse definieren.

6. Die updateShoppingMemo() Methode in unserer Datenquelle ShoppingMemoDataSource anlegen

Das Ändern von Datensätzen werden wir von unserer Datenquelle ausführen lassen. Dazu werden wir die Methode updateShoppingMemo() 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.

6.1 Die Methode updateShoppingMemo() 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:


Das Ändern von Datensätzen in einer SQLite Datenbank ist sehr einfach. Als Erstes erzeugt man ein ContentValues-Objekt und füllt dieses mit den benötigten Schlüssel-Werte-Paaren (Key-Value-Pairs), wie in den Zeilen 2 bis 4 dargestellt. Der Schlüssel ist dabei immer der Name der entsprechenden Spalte und der Wert entspricht dem neuen Inhalt.

Mit der Anweisung in Zeile 6 bis 9 wird der entsprechende Datensatz geändert. Dazu wird die update() Methode auf dem SQLiteDatabase-Objekt aufgerufen. Als Argumente übergeben wir den Tabellennamen, das ContentValues-Objekt und das Suchkriterium, hier die ID des zu ändernden Datensatzes. Das vierte Argument wird nicht benötigt und ist daher null.

Mit den restlichen Zeilen lesen wir den eben abgeänderten Datensatz wieder aus und erzeugen daraus ein ShoppingMemo-Objekt, welches wir am Ende der Methode als Rückgabewert der aufrufenden Methode übergeben.

6.2 Der komplette Quellcode der ShoppingMemoDataSource-Klasse

Nun haben wir die neue Methode updateShoppingMemo() in der ShoppingMemoDataSource-Klasse definiert und das Ändern von Datensätzen in 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 datasource update

Die überarbeitete Klasse ShoppingMemoDataSource mit Markierungen

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

Diese neue Methode werden wir im nächsten Abschnitt nutzen und erstmals Datensätze in unserer SQLite Datenbank ändern. Dazu werden wir die Contextual Action Bar nutzen und über ihren neuen Action Item (Ändern-Aktion) Einträge des ListView und gleichzeitig auch der SQLite Datenbank ändern. Über den neuen Action Item werden wir unseren, in dieser Lektion definierten, AlertDialog aufrufen und durch ihn die Eingaben des Users erfassen.

7. Die Contextual Action Bar in der MainActivity erweitern

Nun werden wir die Contextual Action Bar in der MainActivity-Klasse erweitern. Dazu werden wir die MainActivity um eine neue Methode erweitern, mit der wir einen AlertDialog erstellen lassen. Mit Hilfe der Contextual Action Bar und dem AlertDialog wird es möglich sein, Datensätze der SQLite Datenbank zu ändern.

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

  1. Einfügen der Import-Anweisungen – Zuerst importieren wir die benötigten Klassen und Interfaces.
  2. Definieren der createEditShoppingMemoDialog() Methode – Diese Methode wird den AlertDialog erstellen, mit dem wir Änderungen an den Datensätzen der SQLite Datenbank vornehmen können.
  3. Erweitern der initializeContextualActionBar() Methode – In dieser Methode haben wir einen MultiChoiceModeListener für den ListView registriert und somit die Contextual Action Bar initialisiert. Wir erweitern nun die Callback-Methoden der Contextual Action Bar, um Einträge des ListViews und gleichzeitig auch der hinterlegten SQLite Datenbank ändern zu können. Die Eingabe der neuen Werte erfassen wir mit einem AlertDialog, den wir über die Contextual Action Bar aufrufen werden.

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

Nun beginnen wir mit dem ersten Arbeitsschritt.

7.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:


7.2 Definieren der createEditShoppingMemoDialog() Methode

Im zweiten Arbeitsschritt definieren wir die Methode createEditShoppingMemoDialog(), die für uns den AlertDialog erstellen wird. Die neue Methode erstellt ein AlertDialog-Objekt und gibt es anschließend an die aufrufende Methode zurück.

Dazu fügen wir den folgenden Quellcode in den Methodenbereich der MainActivity-Klasse ein.


Das Grundgerüst der neuen Methode sollte uns schon bekannt sein, da wir die meisten Anweisungen bereits im Theorie-Teil dieser Lektion kennengelernt haben.

In Zeile 3 erstellen wir das AlertDialog.Builder-Objekt, mit dessen Hilfe wir unseren AlertDialog zusammenbauen. Anschließend fragen wir den LayoutInflater, den wir für das Erzeugen des Dialog-Views aus der Layout-Datei benötigen.

In Zeile 6 erzeugen wir aus der Layout-Datei unseres AlertDialogs ein View-Objekt. Dieses View-Objekt weisen wir in Zeile 14 unserem AlertDialog zu. Es wird den mittleren Bereich des Dialogs einnehmen, also zwischen Titel und Buttons.

Doch bevor wir dies tun, suchen wir mit Hilfe des View-Objekts nach den EditText-Feldern unseres AlertDialogs und setzen deren Inhalte auf die Werte der angeklickten ShoppingMemo. Die entsprechenden Anweisungen sind in den Zeilen 8 bis 12 angegeben.

Wie bereits beschrieben, weisen wir in Zeile 14 das View-Objekt unserem AlertDialog zu. Dazu rufen wir die Methode setView() auf dem AlertDialog.Builder-Objekt auf. Anschließend legen wir einen Titel für unseren Dialog fest.

Jetzt folgt der etwas kompliziertere Teil unserer neuen Methode. In den Zeilen 16 bis 43 fügen wir dem AlertDialog zwei Button hinzu und registrieren für beide einen OnClickListener.

Klickt der Nutzer auf den positiven Button (Ändern), lesen wir zuerst die neuen Werte aus den EditText-Feldern aus und speichern diese dann in der SQLite Datenbank mit Hilfe der updatedShoppingMemo() unserer Datenquelle.

Anschließend weisen wir unsere SQLite App mit showAllListEntries() an, den ListView zu aktualisieren und dadurch die geänderten Werte des angeklickten Listeneintrags zusammen mit den unveränderten Einträgen auf dem Display auszugeben. Mit der Anweisung in Zeile 36 lassen wir den AlertDialog wieder schließen.

Klickt der Benutzer auf den negativen Button (Abbrechen), wird die cancel() Methode aufgerufen und dadurch der Dialog geschlossen.

Nun haben wir alle erforderlichen Eigenschaften unseres AlertDialogs definiert und können ihn jetzt zusammenbauen lassen. Dies erfolgt mit der return-Anweisung in Zeile 45. Wir lassen das AlertDialog-Objekt von dem Builder erstellen und geben es als Rückgabewert an die aufrufende Methode zurück.

Das war auch schon alles. Jetzt können wir mit einem Aufruf der Methode createEditShoppingMemoDialog() einen AlertDialog erstellen lassen und über ihn Datensätze unserer SQLite Datenbank ändern.

Wir sind nun einen großen Schritt weiter gekommen, was jetzt noch fehlt ist eine Möglichkeit die neue Methode über die grafische Benutzeroberfläche ausführen zu lassen. Dies werden wir im letzten Arbeitsschritt realisieren, indem wir die Methode initializeContextualActionBar() erweitern.

7.3 Erweitern der initializeContextualActionBar() Methode

Als letzte Änderung an unserem Projekt-Quellcode werden wir die Methode initializeContextualActionBar() erweitern. In ihr initialisieren wir die Contextual Action Bar, indem wir ihren MultiChoiceModeListener implementieren. Bisher haben wir zwei seiner fünf Callback-Methode überschrieben. Nun werden wir uns auch seine restlichen drei Callbacks vornehmen.

Wir löschen dazu unsere bisherige initializeContextualActionBar() Methode im Methodenbereich der MainActivity-Klasse und ersetzen sie mit folgendem Quellcode:


In dem oberen Quellcode wurde über jede der fünf Callback-Methoden eine kurze Erläuterung eingefügt, Dadurch kann leichter nachvollzogen werden, was die Aufgabe des jeweiligen Callbacks ist.

Das sind die fünf Callback-Methoden des Listeners:

  • onItemCheckedStateChanged() – Wird aufgerufen, wenn ein Eintrag ausgewählt oder abgewählt wird. Hier zählen wir die Anzahl der ausgewählten Listeneinträge mit.
  • onCreateActionMode() – Wird bei Erzeugen der Contextual Action Bar aufgerufen. Hier legen wir die Menüeinträge (Action Items) an.
  • onPrepareActionMode – Wird aufgerufen, wenn die Contextual Action Bar erzeugt wurde und manuell über die invalidate() Methode. Hier blenden wir das Ändern-Symbol aus, wenn mehr als ein Listeneintrag ausgewählt wurde.
  • onActionItemClicked() – Wird aufgerufen, wenn ein Action Item, also ein Menüeintrag der Contextual Action Bar angeklickt wurde. Hier reagieren wir auf Klicks auf das Löschen- und Ändern-Symbol.
  • onDestroyActionMode() – Wird aufgerufen, wenn der Action Mode beendet und somit auch die Contextual Action Bar geschlossen wird. Hier setzen wir den Zähler wieder auf 0 zurück.

Der Quellcode ist größtenteils selbsterklärend. Nur die onActionItemClicked() Callback-Methode ist etwas komplexer. Den ersten Teil haben wir bereits in der vorherigen Lektion des Android SQLite Tutorials kennengelernt. Neu ist der mittlere Teil in der Switch-Anweisung in den Zeilen 67 bis 82.

Darin lesen wir das zugehörige ShoppingMemo-Objekt aus dem angeklickten Listeneintrag aus. Anschließend lassen wir mit der Methode createEditShoppingMemoDialog() den AlertDialog erstellen und diesen mit der Methode show() anzeigen. Mit dem so erzeugten AlertDialog kann der entsprechende Datensatz unserer SQLite Datenbank geändert werden.

Weitere Infos über die Callback-Methoden des Action Modes könnt ihr hier finden:

7.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 bzw. ändern 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 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 kompletten Methoden initializeContextualActionBar() und createEditShoppingMemoDialog() sind mit B bzw. C markiert.

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

8. 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 in der SQLite Datenbank geändert 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 in dem ListView der MainActivity geändert werden.

8.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.

8.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 update log

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

Nun klicken wir lange auf den zweiten Listeneintrag 3 x Saft, wodurch die Contextual Action Bar über die normale Action Bar gelegt wird. In der Contextual Action Bar befinden sich nun zwei Symbole, ein Stift und ein Mülleimer. Außerdem erhalten wir Rückmeldung darüber wie viele Einträge gerade ausgewählt worden sind.

Mit einem Klick auf das Ändern-Symbol, den Stift, öffnet sich der AlertDialog und wir können den den ausgewählten Datensatz unserer SQLite Datenbank ändern. Wir erhöhen die Anzahl von 3 auf 4 und ändern Saft in Säfte um. Anschließend bestätigen wir die Änderung des Listeneintrags mit dem Ändern-Button.

Jetzt haben wir den vorher ausgewählten Listeneintrag geändert, was wir auch direkt im ListView angezeigt bekommen. Als Nächstes schließen wir die SQLite App mit einem Klick auf den Back-Button.

In der unteren Abbildung sind die Log-Meldungen nach dem Ändern des zweiten Listeneintrags und anschließendem Beenden unserer Android App dargestellt. Die Log-Meldungen werden im logcat-Textbereich angezeigt. Die Meldungen, die über den Änderungsvorgang informieren, sind von einem blauen Rahmen (Markierung 1) umschlossen.

android sqlite update log

Überprüfen der Log-Meldungen in Android Studio mit aktivem Log-Filter – Eintrag geändert und 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: 5, Inhalt: 3 x Kartoffeln
11: MainActivity﹕ Eintrag ändern
12: MainActivity﹕ Position im ListView: 1 Inhalt: 3 x Saft
14: MainActivity﹕ Alter Eintrag – ID: 2 Inhalt: 3 x Saft
15: MainActivity﹕ Neuer Eintrag – ID: 2 Inhalt: 4 x Säfte
16: ShoppingMemoDataSource﹕ ID: 1, Inhalt: 5 x Äpfel
17: ShoppingMemoDataSource﹕ ID: 2, Inhalt: 4 x Säfte
18: ShoppingMemoDataSource﹕ ID: 5, Inhalt: 3 x Kartoffeln
19: MainActivity﹕ Die Datenquelle wird geschlossen.
20: ShoppingMemoDataSource﹕ Datenbank mit Hilfe des DbHelpers geschlossen.

Die meisten Log-Meldungen sind bereits bekannt. Neu sind die Meldungen 11 bis 18, die über den geänderten Datenbankeintrag informieren und den aktuellen Inhalt der SQLite Datenbank ausgeben.

In der unteren Abbildung ist das Vorgehen für das Ändern eines Datensatzes unserer SQLite Datenbank mit Hilfe der Contextual Action Bar noch einmal dargestellt:

android sqlite update

Einträge der SQLite Datenbank mit Hilfe der Contextual Action Bar und einem AlertDialog ändern

Ein Video veranschaulicht den Änderungsvorgang 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.

8.3 Video – Funktionspräsentation unserer SQLite App

In dem unteren Video haben wir einen Eintrag aus dem ListView und somit auch aus der SQLite Datenbank geändert. Im Video ist zu sehen, wie das Ändern mit Hilfe der Contextual Action Bar funktioniert. Außerdem wird gezeigt, wie das Ändern-Symbol ausgeblendet wird, wenn mehr als ein Listeneintrag ausgewählt ist.

Mit dieser neuen Funktion ist unsere Einkaufslisten-App jetzt schon ziemlich ausgereift. Unsere SQLite App ist zwar noch nicht vollständig, aber bereits vernünftig nutzbar.

In der nächsten Lektion unseres Android SQLite Datenbank Tutorials werden wir die App um eine wichtige Funktion erweitern, dem 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 des Android SQLite Tutorials haben wir neben dem SQL-Befehl update auch den AlertDialog von Android kennengelernt. Außerdem haben wir auch die Contextual Action Bar besser kennengelernt.

Zu Beginn dieser Lektion haben wir uns im Theorie-Teil mit dem Ändern von Datensätzen einer SQLite Datenbank beschäftigt. Dabei wurden auch die Callback-Methoden der Contextual Action Bar besprochen und die Klasse AlertDialog von Android vorgestellt.

Anschließend haben wir unser Android Projekt erweitert. Wir haben weitere String-Konstanten angelegt, einen zweiten Menüeintrag der Contextual Action Bar hinzugefügt und ein Layout für den AlertDialog definiert. Danach haben wir in unserer Datenquelle eine neue Methode für das Ändern von Datensätzen der SQLite Datenbank definiert.

Die größten Änderungen haben wir an der MainActivity vorgenommen. In dieser Klasse haben wir eine neue Methode erstellt, mit der wir einen AlertDialog erstellen lassen, und die Callback-Methoden der Contextual Action Bar erweitert.

Abschließend haben wir unsere SQLite App auf dem Android Gerät ausgeführt und die Log-Meldungen analysiert. Zusätzlich haben wir den aktuellen Entwicklungsstand unserer Android App in einem Video festgehalten.

In dem nächsten Teil unseres Android SQLite Tutorials werden wir unsere Einkaufslisten-App um eine wichtige Funktion erweitern, dem Abhaken von Einträgen. Die Nutzer sollen mit einem kurzen Klick auf einen Eintrag des ListViews diesen abhaken können, dabei wird der zugehörige Text durchgestrichen werden.


Comments 1

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

Hinterlasse eine Antwort

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