In diesem Tutorial lernt ihr:
- Was ist das SQLite Datenbanksystem
- Ziele des Android SQLite Tutorials
- Vorkenntnisse und Voraussetzungen
- Inhalte des SQLite Tutorials
Ihr solltet auch lesen:
In diesem Tutorial entwickeln wir eine Android™ App, in die wir eine SQLite Datenbank integrieren.
Unser Android SQLite Tutorial richtet sich an alle Programmierer, die eine eigene SQLite Datenbank App programmieren möchten und den Einstieg in die Entwicklung von Android Apps bereits gemeistert haben.
In 8 großen Lektionen werden wir gemeinsam eine Android App entwickeln und in diese eine SQLite Datenbank integrieren. Dabei werden wir am Beispiel einer eigenen App vermitteln, wie eine SQLite Datenbank in Android eingebunden und verwendet wird.
Als SQLite Anwendung werden wir eine Einkaufslisten-App programmieren, mit der eine eigene Einkaufsliste erstellt werden kann. Die Einträge der Einkaufsliste werden mit Hilfe eine SQLite Datenbank verwaltet. Im Laufe des Kurses werden wir erfahren, wie Datensätze in die Datenbank geschrieben, aus ihr ausgelesen, verändert und auch gelöscht werden.
Die eigene Android App wird dabei schrittweise entstehen und am Ende des Kurses zu einer vollständigen Android Anwendung angewachsen sein.
Auf dieser Übersichtsseite des Android SQLite Tutorials stellen wir die einzelnen Lektionen kurz vor. Wir empfehlen die Beschreibungen der einzelnen Lektionen zu lesen und anschließend mit der Lektion zu beginnen. Ihr könnt aber auch per Schnellzugriff direkt zur jeweiligen Tutorial Lektion springen.
Hinweis: Die im Verlauf dieses Kurses programmierte SQLite App wird Lektion für Lektion entstehen und dabei schrittweise neue Funktionen erhalten, daher sollten die Lektionen unbedingt der Reihe nach absolviert und kein Arbeitsschritt übersprungen werden.
Wir wünschen nun viel Spaß mit unserem SQLite Datenbank App Programmieren Kurs!
Schnellzugriff auf die Lektionen des Android SQLite Tutorials
1. Was ist SQLite und wie ist es in Android integriert?
SQLite ist eine Programmbibliothek, welche ein relationales Datenbanksystem enthält. Das Open Source Datenbanksystem unterstützt eine Vielzahl der SQL-Sprachbefehle und wurde vor allem für den Einsatz in eingebetteten Umgebungen entworfen.
Besonders häufig wird das Datenbanksystem SQLite auf Betriebssystemen für Smartphones und Tablets eingesetzt, bspw. Symbian OS oder Android.
Der große Vorteil des SQLite Datenbanksystems ist der minimale Aufbau der Bibliothek. Die gesamte SQLite-Bibliothek ist nur einige hundert Kilobyte groß und lässt sich direkt in die Android Anwendung integrieren. Es wird keine weitere Server-Software benötigt.
Durch das Einbinden der SQLite-Bibliothek wird eine Android App um sehr nützliche Datenbankfunktionen erweitert, ohne auf externe Software angewiesen zu sein. Die SQLite-Datenbank besteht aus einer einzigen Datei, die alle Tabellen, Indizes usw. enthält.
1.1 Wie ist SQLite in das Android System integriert?
In Android ist das SQLite Datenbanksystem fester Bestandteil der Laufzeitumgebung. Dadurch kann jede Android App sehr einfach und effizient Daten in Form einer Datenbank ablegen und auslesen.
Das Einrichten und die Administration der Datenbank wird von Android übernommen. Wir müssen nur mit Hilfe von SQL-Anweisungen die Datenbank anlegen und updaten. Anschließend wird die Datenbank automatisch vom Android System verwaltet.
Die Klassen, die für das Einbinden einer SQLite-Datenbank in einer Android App benötigt werden, sind in dem Package android.database.sqlite zusammengefasst. Wir werden in diesem Android SQLite Tutorial die Klasse SQLiteOpenHelper verwenden und dabei näher kennenlernen.
2. Lernziele des Android SQLite Tutorials
Diese Android SQLite Datenbank App werden wir gemeinsam programmieren
In diesem Android SQLite Tutorial lernt ihr das SQLite Datenbanksystem effektiv und sicher zu nutzen. Wir entwickeln gemeinsam im Rahmen dieses Kurses eine Einkaufslisten-App. Für das Programmieren der App werden wir die Entwicklungsumgebung Android Studio verwenden.
Mit der programmierten SQLite Datenbank App wird es möglich sein eine virtuelle Einkaufsliste zu erstellen. Dabei lernt ihr, wie man eine SQL-Datenbank erzeugt, Datensätze in die Datenbank schreibt und wieder aus dieser auslest. Später werden wir auch das Löschen und Verändern von Datensätzen vorstellen.
Am Ende unseres SQLite Datenbank App Programmieren Online-Kurses kennt ihr die Grundlagen der Datenbank-basierten Android App Entwicklung, versteht die Prinzipien und Vorgehensweisen bei der Arbeit mit dem SQLite Datenbanksystem und könnt die Entwicklungswerkzeuge gekonnt einsetzen.
Ihr habt die größten Herausforderungen bei der Entwicklung von SQLite Anwendungen kennengelernt und habt sie gemeistert. Das Erlernte könnt ihr anschließend in anderen Anwendungsgebieten wiederverwenden, bspw. indem ihr in eure eigene Android App eine SQLite Datenbank einbindet.
Hinweis: Die SQLite App ist so konzipiert, dass der Lernstoff möglichst gut vermittelt werden kann. Dabei stehen die Themen für das Verwenden einer SQLite Datenbank immer im Vordergrund. Aber auch verwandte Themen werden behandelt, wie bspw. der Android Activity Lifecycle, das Verwenden einer Contextual Action Bar und das Erfassen von Benutzereingaben mit Hilfe von Event Listenern.
In dem folgenden Video ist unsere Einkaufslisten-App in Aktion zu sehen:
3. Welche Vorkenntnisse und Voraussetzungen werden benötigt?
Da Android Apps in der Programmiersprache Java programmiert werden, ist es notwendig, dass ihr erste Erfahrungen mit Java oder einer objektorientierten Programmiersprache bereits gemacht habt. In unserem Java-Kurs könnt ihr die Sprache Java lernen oder bereits erlangtes Wissen erneuern bzw. vertiefen.
Zudem ist es sehr hilfreich, wenn ihr bereits eure erste eigene Android App programmiert habt. Falls ihr noch Neulinge auf dem Gebiet der Android App Entwicklung seid, könnt ihr unseren großen Android Apps Programmieren Online-Kurs absolvieren. Mit unserem Android Apps Programmieren Kurs gelingt euch der Einstieg in die Entwicklung von Android Anwendungen garantiert. Danach seid ihr bestens auf unseren SQLite Datenbank App Programmieren Online-Kurs vorbereitet.
Die App werden wir mit Hilfe der Entwicklungsumgebung Android Studio entwickeln. Daher ist es notwendig, dass ihr Android Studio auf eurem PC installiert habt. Wie die Installation von Android Studio durchgeführt wird, zeigen wir in unserem großen Android Kurs. Weiterhin ist es sehr hilfreich, wenn ihr ein Android Smartphone oder Tablet besitzt. Dies ist aber nicht unbedingt erforderlich, da die entwickelte Android App sowohl auf einem Android Gerät als auch auf dem Android Emulator getestet und ausgeführt werden kann.
Da wir eine SQLite-Anwendung entwickeln werden, ist es hilfreich, wenn ihr bereits über etwas Erfahrung mit der Sprache SQL (Structured Query Language) verfügt. Dies ist wichtig, da das SQLite Datenbanksystem eine Vielzahl der SQL-Sprachbefehle unterstützt. Wir werden aber jeden verwendeten SQL-Befehl ausführlich beschreiben, so dass auch absolute SQL-Novizen ohne Probleme die Lektionen unseres Online-Kurses absolvieren können.
4. Inhalte des Android SQLite Tutorials
Das Android SQLite Datenbank App Tutorial gliedert sich in 8 große Lektionen, in denen jeweils ein ganz bestimmtes Themengebiet der Android SQLite Datenbank Entwicklung behandelt wird. Die beiden Basis-Lektionen vermitteln die grundlegenden SQLite Datenbank Themen. Ihnen folgen die Premium-Lektionen, in welchen fortgeschrittene SQLite Themen behandelt werden.
Die Grundlagen der Entwicklung einer realen SQLite Datenbank App praxisnah und verständlich zu lehren, ist das Hauptziel des SQLite Datenbank App Programmieren Online-Kurses. Um dieses Ziel zu erreichen, wird im Verlauf des Kurses eine eigene SQLite App programmiert und so die theoretischen Lerninhalte direkt in die Praxis umgesetzt.
Die App wird dabei schrittweise entstehen und von Lektion zu Lektion an Funktionsumfang gewinnen. Die Reihenfolge der Lektionen muss zwingend eingehalten werden, da die Android App von Lektion zu Lektion weiterentwickelt wird und nachfolgende Lektionen auf vorherigen aufbauen.
Hinweis: Weiterhin bilden die ersten beiden Lektionen die Grundlage des SQLite Tutorials und sollten unbedingt in Ruhe ausgeführt werden. Die späteren Lektionen fügen der SQLite App dann immer eine neue Funktion hinzu und führen tiefer in die verwandten Themen ein.
In der unteren Übersicht sind die einzelnen Lektionen des SQLite Datenbank App Programmieren Tutorials aufgeführt. Insgesamt besteht das Android SQLite Tutorial aus 8 großen Lektionen.
Lektion 1: Das SQLite Projekt in Android Studio anlegen
Die zentralen Dateien des Android SQLite Projekts
In der ersten Lektion unseres SQLite Tutorials werden wir zunächst das Android Studio Projekt anlegen und anschließend die grundlegende Struktur unserer Anwendung definieren.
Als SQLite Anwendung werden wir eine Einkaufslisten-App programmieren. Die App soll intuitiv und einfach zu bedienen sein. Die Benutzer können mit Hilfe der grafischen Oberfläche Einträge in die virtuelle Einkaufsliste tätigen. Dabei besteht jeder Eintrag aus dem Namen des zu kaufenden Produkts und der jeweiligen Mengenangabe.
Diese Daten werden von unserer App in eine Android SQLite Datenbank gespeichert. Um die gespeicherten Datensätze auf dem Android Gerät auszugeben, werden wir einen ListView verwenden, der über einen Adapter mit der Datenquelle verbunden sein wird.
Unsere Android SQLite App wird Lektion für Lektion entstehen und dabei schrittweise neue Funktionen erhalten. Zu Beginn erstellen wir, wie bereits erwähnt, das Android Studio Projekt und nehmen an den generierten Projektdateien einige Änderungen vor.
Wir legen die benötigten String-Konstanten in der strings.xml Datei an und nehmen Anpassungen an dem Erscheinungsbild unserer App in der colors.xml Datei vor. Zudem definieren wir das Layout unserer SQLite App in der Layout-Ressourcen Datei der MainActivity, so dass die Benutzer später Einträge in die SQLite Datenbank mit Hilfe der grafischen Oberfläche vornehmen können.
Am Ende der Lektion werden wir unsere Android App das erste Mal auf einem Android Gerät ausführen und dabei das Layout der grafischen Benutzeroberfläche unserer SQLite Anwendung überprüfen.
Da wir in diesem SQLite Kurs mit dem hier erstellten Android Studio Projekt arbeiten, sollten die Lektionen unbedingt der Reihe nach absolviert und kein Arbeitsschritt übersprungen werden.
Lektion 2: Integrieren einer SQLite Datenbank in Android
Beziehungen der Klassen unserer SQLite App
In der zweiten Lektion unseres Android SQLite Tutorials werden wir das Rahmenwerk der SQLite Datenbank Anwendung erstellen.
Dazu werden wir die folgenden drei Java-Klassen mit Hilfe von Android Studio anlegen:
- ShoppingMemo – Instanzen dieser Klasse können die Daten eines SQLite-Datensatzes aufnehmen. Sie repräsentieren die Datensätze im Code. Wir werden mit Objekten dieser Klasse den ListView füllen.
- ShoppingMemoDbHelper– Sie ist eine Hilfsklasse mit deren Hilfe wir die SQLite-Datenbank erstellen lassen. Sie enthält weiterhin wichtige Konstanten, die wir für die Arbeit mit der Datenbank benötigen, wie den Tabellennamen, die Datenbankversion oder die Namen der Spalten.
- ShoppingMemoDataSource– Diese Klasse ist unser Data Access Object und für das Verwalten der Daten verantwortlich. Es unterhält die Datenbankverbindung und ist für das Hinzufügen, Auslesen und Löschen von Datensätzen zuständig. Außerdem wandelt es Datensätze in Java-Objekte für uns um, so dass der Code unserer Benutzeroberfläche nicht direkt mit den Datensätzen arbeiten muss.
Jede dieser Klassen übernimmt eine bestimmte Aufgabe bei der Arbeit mit dem SQLite Datenbanksystem. Doch bevor wir die Klassen anlegen, werden wir uns ausführlich mit dem SQLite Datenbanksystem befassen und dabei auch auf die Frage eingehen, wie SQLite in das Android System integriert ist.
Anschließend beschreiben wir, auf welche Art die SQLite Datenbank in unsere Einkaufslisten-App integriert werden soll. Dabei gehen wir auch auf die drei zu erstellenden Java-Klassen näher ein und beschreiben, wofür wir die jeweilige Klasse benötigen. Am Ende der Lektion führen wir unsere SQLite App im Emulator aus und überprüfen, ob die neuen Klassen ordnungsgemäß angelegt wurden und wie erwartet funktionieren.
Zugang zu den Android Online-Kursen freischalten
Durch den Kauf unseres Android Online-Kurs Gesamtpakets erhältst du zeitlich unbegrenzten Zugang zu allen 43 Lektionen unserer beiden Android Online-Kurse:
- Android Apps Programmieren Online-Kurs – In 35 großen Lektionen zeigen wir dir, wie du Schritt für Schritt deine eigene Android App entwickelst. Im Kurs werden die grundlegenden Themen der Android App Entwicklung detailliert behandelt und verständlich in die Praxis umgesetzt.
- SQLite Datenbank App Programmieren Online-Kurs – In 8 großen Lektionen entwickeln wir gemeinsam eine SQLite Datenbank App. Dabei werden wir am Beispiel der eigenen App vermitteln, was eine SQLite Datenbank ist und wie sie in Android verwendet wird.
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.
Einmal kaufen für nur 29,95 €* und dadurch zeitlich unbegrenzten Zugriff auf alle Inhalte unserer Android Online-Kurse erhalten.
für nur 29,95 €* kaufenWeitere Infos über
unsere Android Kurse
*Alle angegebenen Preise sind Endpreise inkl. MwSt.
Premium-Inhalte des SQLite App Tutorials
Hier geht es nun weiter mit den Premium-Lektionen unseres SQLite Android Kurses. Wir hoffen, ihr konntet mit Hilfe der freien Lektionen einen Einblick in unseren Kurs erhalten und dass es uns gelungen ist, euer Interesse für die Entwicklung von Android SQLite Apps zu wecken.
Alle Premium-Lektionen, befinden sich im geschützten Bereich von ProgrammierenLernenHQ und sind für alle Käufer unseres Android Online-Kurs Gesamtpakets zugänglich.
Welche fortgeschrittenen SQLite Themen euch im Premium-Bereich unseres Android Kurses erwarten, stellen wir nun ausgiebig vor. Wir haben zu jeder Premium-Lektion eine kurze Zusammenfassung erstellt, in der die darin behandelten Themen vorgestellt werden.
Auf diese Weise könnt ihr den weiteren Kursverlauf kennenlernen und sehen, wie die gemeinsam entwickelte Android App Lektion für Lektion an Funktionsumfang gewinnt.
Lektion 3: Erstellen einer Tabelle in die SQLite Datenbank
Mit Log-Meldungen überprüfen wir, ob die Tabelle korrekt in der SQLite Datenbank angelegt wurde
In der dritten Lektion unseres Android SQLite Tutorials werden wir eine Tabelle in unserer SQLite Datenbank erstellen. Dazu werden wir Veränderungen an drei Klassen unseres SQLite Projekts vornehmen.
Doch bevor wir mit dem Programmieren beginnen, werden wir uns damit beschäftigen, wie man eine Tabelle in die Android SQLite Datenbank einfügt.
Dabei betrachten wir auch, was sich hinter den Kulissen abspielt. Also welche Schritte im Android System beim Erstellen der Tabelle im Hintergrund ablaufen.
Anschließend werden wir in der Klasse ShoppingMemoDbHelper die Eigenschaften unserer SQLite Datenbank und der zu erstellenden Tabelle definieren. Danach stellen wir in der ShoppingMemoDataSource-Klasse eine Verbindung zu unserer SQLite Datenbank her. Dabei wird automatisch vom Android System die Tabelle nach unseren Vorgaben erstellt.
Um die Änderungen an dem Quellcode zu testen, werden wir von der MainActivity-Klasse aus auf die DataSource zugreifen. Dazu fügen wir den notwendigen Testcode in die Klasse MainActivity ein.
Somit werden wir folgende Arbeitsschritte in dieser Lektion des SQLite Kurses ausführen:
- Definieren der Eigenschaften unserer Datenbank in der ShoppingMemoDbHelper-Klasse.
- Herstellen der Verbindung zur SQLite Datenbank in der ShoppingMemoDataSource-Klasse.
- Öffnen der Datenquelle und Zugriff auf die Datenbank in der MainActivity-Klasse
Lektion 4: Daten in die SQLite Datenbank schreiben und auslesen
Unsere SQLite App zeigt den Inhalt der ihrer Datenbank an
In der vierten Lektion unseres Android SQLite Tutorials werden wir Daten in die SQLite Datenbank schreiben und wieder auslesen.
Zu Beginn werden wir uns mit den Fragen beschäftigen:
Anschließend werden wir mit Hilfe unsere Datenquelle ShoppingMemoDataSource Daten in die Datenbank schreiben und auslesen.
Die Datenquelle ist unser Data Access Object. Sie unterhält die Datenbankverbindung und unterstützt uns beim Erstellen neuer Datenbankeinträge und auch beim Auslesen der bereits vorhandenen Einträge.
Danach überarbeiten wir die MainActivity-Klasse, so dass erste Datensätze als Testeinträge in die Datenbank geschrieben werden. Anschließend lassen wir uns Inhalt der SQLite Datenbank von dem ListView der MainActivity anzeigen. Am Ende der vierten Lektion des Android SQLite Kurses werden wir unsere App ausführen und dabei überprüfen, ob die Daten korrekt in die SQLite Datenbank geschrieben werden.
Die vierten Lektion ist ein großer Entwicklungsschritt für unsere Android SQLite App. Nach Abschluss der vierten Lektion wird unsere Einkaufslisten-App in der Lage sein, Daten in die Datenbank zu schreiben, diese auszulesen und auf dem Display auszugeben.
Lektion 5: Mit der SQLite App auf Benutzereingaben reagieren
In unsere SQLite Datenbank App können nun echte Einträge geschrieben werden
In der fünften Lektion unseres Android SQLite Tutorials werden wir unserer Android App Funktionalität hinzufügen. Wir werden auf Benutzereingaben reagieren und erfassen welche Werte in die EditText-Felder eingetragen sind.
Die grafische Benutzeroberfläche steuern wir von der MainActivity aus. Daher wird sie auch die einzige Klasse sein, deren Quellcode wir in dieser Lektion überarbeiten.
Doch bevor wir Änderungen an der Projektdatei vornehmen, werden wir uns mit dem Lebenszyklus von Activities und Fragmenten näher beschäftigen. Der Android Lifecycle ist für die Arbeit mit Datenbanken sehr wichtig, da man genau wissen muss, wann die Verbindung zur SQLite Datenbank geöffnet bzw. geschlossen werden sollte. Nachdem wir den Android Lifecycle besser kennengelernt haben, werden wir uns mit den Fragen beschäftigen: Wie man ein EditText-Feld in Android ausliest und wie erkannt wird, ob ein Button vom Benutzer angeklickt wurde.
Nach dem theoretischen Teil der Lektion werden wir das Gelernte in unserer SQLite App einsetzen und dabei die MainActivity-Klasse umstrukturieren und erweitern. Wir werden die Life Cycle Callback-Methoden onResume() und onCreate() überschreiben, um in ihnen die Verbindung zur Datenbank korrekt zu verwalten.
Weiterhin werden wir einen OnClickListener für den Add-Button registrieren und so auf Benutzereingaben reagieren. Durch einen Klick auf den Button sollen die in die EditText-Felder eingetragenen Werte in die Tabelle der SQLite Datenbank geschrieben werden. Abschließend werden wir unsere SQLite App ausführen und testen, dabei werden wir erstmals echte Werte in die Datenbank über die grafische Benutzeroberfläche eintragen.
Lektion 6: Daten mit Hilfe der Contextual Action Bar aus der SQLite Datenbank löschen
Mit Hilfe der Contextual Action Bar können auch mehrere Einträge gleichzeitig aus der SQLite Datenbank gelöscht werden
In der sechsten Lektion unseres 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:
Anschließend werden wir ein Menu Resource File für die Contextual Action Bar anlegen und dem Quellcode der ShoppingMemoDataSource-Klasse eine Methode zum Löschen von Datensätzen aus der SQLite Datenbank hinzufügen.
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.
Die folgende Abbildung zeigt den Ablauf einer Lösch-Aktion in unserer SQLite App:
Einträge aus der SQLite Datenbank mit Hilfe der Contextual Action Bar löschen
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.
Lektion 7: Daten mit Hilfe der Contextual Action Bar in der SQLite Datenbank ändern
Einträge aus der SQLite Datenbank mit der Contextual Action Bar ändern
In der siebten Lektion unseres 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. Da der ListView mit der Datenbank verbunden ist, ändern sich dadurch auch automatisch dessen Einträge.
Das Ändern der Datenbankeinträge wird über die Contextual Action Bar ausgelöst werden. Dabei können die Änderungen an den bestehenden Daten mit Hilfe eines eingeblendeten Dialogs vom Benutzer vorgenommen werden.
Wie so etwas in Android realisiert wird, werden wir ausführlich im theoretischen Teil der Lektion behandeln. Wir werden beschreiben, wie mit der Contextual Action Bar dynamisch auf die Benutzereingaben reagiert werden kann und wie in Android Dialoge zur Datenerfassung genutzt werden.
Anschließend setzen wir das Gelernte in die Praxis um und implementieren die neue Funktion unserer SQLite App.
Um dies zu realisieren, werden wir die folgenden Arbeitsschritte durchführen:
- Definieren eines weiteren Action Items in der Menü-Datei der Contextual Action Bar.
- Erstellen der Layout-Datei für den eingeblendeten EditShoppingMemo-Dialog.
- Erweitern unserer Datenquelle (DataSource) um die updateShoppingMemo() Methode.
- Erweitern der Callback-Methoden der Contextual Action Bar in der MainActivity-Klasse.
Abschließ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.
Die folgende Abbildung zeigt den Ablauf einer Eintrag Ändern-Aktion in unserer SQLite App:
Einträge der SQLite Datenbank mit Hilfe der Contextual Action Bar ändern
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.
Lektion 8: Durchführen eines SQLite Datenbank Upgrades in Android
Einträge der SQLite Datenbank können nun im ListView durch Abhaken durchgestrichen werden
In der achten Lektion unseres Android SQLite Tutorials werden wir die Entwicklung an unserer Einkaufslisten-App abschließen. Wir fügen der SQLite App eine Durchstreichen-Funktion hinzu.
Die User sollen Listeneinträge abhaken können, wenn sie kurz auf ein Element des ListViews klicken. Wird ein Listeneintrag abgehakt, dann lassen wir den Text des zugehörigen TextViews durchstreichen und ausgrauen.
Ob ein Eintrag abgehakt ist oder nicht, möchten wir in unserer SQLite Datenbank speichern.
Im theoretischen Teil dieser Lektion werden wir uns mit der onUpgrade() der DbHelper-Klasse beschäftigen. Dabei werden wir zeigen, wie ein SQLite Datenbank Upgrade durchgeführt wird. Am Ende der achten Lektion unseres Android SQLite Kurses werden wir unsere App auf einem Android Gerät installieren und testen. Dabei werden wir auch wieder die Log-Meldungen analysieren.
Um dies alles zu realisieren, müssen wir alle Klassen unseres Android Projekts überarbeiten. Wir werden an den Klassen folgende Änderungen vornehmen:
- ShoppingMemo – Diese Klasse ist unser Datenmodell und repräsentiert einen Datensatz der SQLite Datenbank. Wir fügen in sie ein weiteres Attribut ein, mit dem wir den Status der jeweiligen ShoppingMemo als checked oder not checked speichern.
- ShoppingMemoDbHelper – Sie ist eine Hilfsklasse mit deren Hilfe wir die SQLite Datenbank erstellen lassen. Sie enthält weiterhin wichtige Konstanten, die wir für die Arbeit mit der Datenbank benötigen, wie den Tabellennamen, die Datenbankversion oder die Namen der Spalten. Wir fügen ihr eine weitere Spalte hinzu und implementieren ihre onUpgrade() Methode, um die SQLite Datenbank neu zu erstellen.
- ShoppingMemoDataSource – Diese Klasse ist unser Data Access Object und für das Verwalten der Daten verantwortlich. Sie unterhält die Datenbankverbindung und ist für das Hinzufügen, Auslesen und Löschen von Datensätzen zuständig. Wir nehmen in dieser Klasse Änderungen an den Methoden updateShoppingMemo() und cursorToShoppingMemo() vor.
- MainActivity – Von dieser Klasse aus, steuern wir unsere SQLite App. Wir fügen ihrem ListView einen OnItemClickListener zu, um damit auf kurze Klicks zu reagieren.
In diesem letzten Teil unseres SQLite Datenbank App Programmieren Tutorials werden wir noch einmal Veränderungen an allen Klassen unseres Projekts vornehmen. Dies wird notwendig sein, da wir die Datenstruktur unserer SQLite Datenbank durch ein Datenbank Upgrade erweitern werden.
Einträge aus der SQLite Datenbank im ListView durchstreichen (abhaken)
Zugang zu den Android Online-Kursen freischalten
Du hast nun die Inhalte unseres SQLite Datenbank App Programmieren Online-Kurses näher kennengelernt. Wir hoffen, dass du dadurch einen Einblick in unseren Android Online-Kurs erhalten konntest und es uns gelungen ist, dein Interesse für die Entwicklung von Android Apps zu wecken.
Falls ja, dann beginne noch heute mit dem Programmieren deiner eigenen Android SQLite App und werde zum Android Entwickler. Mit unseren Android Online-Kursen wird dir dies garantiert gelingen.
Wir hoffen, Dich bald als neuen Kursteilnehmer begrüßen zu dürfen!
Durch den Kauf unseres Android Online-Kurs Gesamtpakets erhältst du zeitlich unbegrenzten Zugang zu allen 43 Lektionen unserer beiden Android Online-Kurse:
- Android Apps Programmieren Online-Kurs – In 35 großen Lektionen zeigen wir dir, wie du Schritt für Schritt deine eigene Android App entwickelst. Im Kurs werden die grundlegenden Themen der Android App Entwicklung detailliert behandelt und verständlich in die Praxis umgesetzt.
- SQLite Datenbank App Programmieren Online-Kurs – In 8 großen Lektionen entwickeln wir gemeinsam eine SQLite Datenbank App. Dabei werden wir am Beispiel der eigenen App vermitteln, was eine SQLite Datenbank ist und wie sie in Android verwendet wird.
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.
Einmal kaufen für nur 29,95 €* und dadurch zeitlich unbegrenzten Zugriff auf alle Inhalte unserer Android Online-Kurse erhalten.
für nur 29,95 €* kaufenWeitere Infos über
unsere Android Kurse
*Alle angegebenen Preise sind Endpreise inkl. MwSt.
Comments 8
Hallo Chris,
zunächst einmal vielen vielen Dank für Deine Super-Tutorials. Du beschreibst wirklich jeden Schritt und das sehr kompetent. Eine der wenigen Tutorial-Quellen, bei dem es fundierte Hilfe und nicht nur Halbwissen gibt. Es hat auch alles super funktioniert, nur bei einer Sache tappe ich im Dunkeln. Die Datenbank wird erstellt und laut LogCat kann ich auch den Datenbankpfad sehen, aber ich kann ihn nirgends auf dem Handy finden. Auch nicht, wenn ich das Handy am PC angeschlossen habe und dort durch die Verzeichnisse wander. Mit der Suchfunktion nach *.db werden mir zwar 2 Datenbanken angezeigt, nicht aber die „shopping_list.db“. Sorry, ich komme aus der PC- und Embedded-Programmierung und bin bei Android ein Neuling. Vielleicht werden ja bestimmte Verzeichnisse nicht angezeigt, aber Du kannst mir da bestimmt weiterhelfen. Vielen Dank im Voraus! VG Werner
Author
Hallo Werner,
danke für deine sehr erfreuliches Feedback! Meine Antwort kommt wahrscheinlich viel zu spät, was ich sehr bedaure.
Auf dem Smartphone oder Tablet hat man keinen Zugriff auf die Datenbank. Möchte man die Datenbank betrachten, muss die App auf einem virtuellen Android Gerät im Android Emulator ausgeführt werden. Dann kann man in Android Studio über das Tool Window -> Device File Explorer auf die Datenbank zugreifen. Sie befindet sich dann an der Stelle auf die der Datenpfad, welchen wir per Logcat ausgeben lassen, zeigt.
Möchte man auf die Datenbank auf dem Smartphone oder Tablet, also einem physikalischen Android Gerät, zugreifen, müsste man diese innerhalb der App auf die SD-Karte exportieren.
Viele Grüße, Chris
Hey,
ich habe ein kleines Problem mit dem SQLite-Tutorial..
Und zwar in der MainActivity.java-Datei..
Anfangs hatte ich noch getippt, aber als ein Fehler erschien
den kompletten Code dann einfach von der Seite kopiert,
was ihn jedoch nicht behoben hat..
Und zwar beginnt es schon fast ganz oben, weil AS rummeckert,
dass es „unused import statement“ hätte, und die Symbols
„.Bundle“, „.Menu“ und „.MenuItem“
nicht aufgelöst („cannot resolve symbol…“) werden könnten.
Weiter geht es dann innerhalb der Klasse mit
„@Override‘ not applicable to method“,
gefolgt von Fehlern ausgelöst durch die
„ungenutzten“ Import-Statements
(rot geschriebene „Bundle“, „Menu“, „MenuItem“,
aber auch „.inflate“ und „.getItemId()“,
sowie „.onOptionsItemSelected(item)“, was für mich
irgendwie danach aussieht, dass die Klasse, welche eben
jene Elemente zur Verfügung stellt nicht bekannt ist….)
Markiere nun irgendeinen der rote geschriebenen Begriffe,
dann unterstreicht AS das „MenuItem“ in der dritten Funktion
(„public boolean onOptionsItemSelected(MenuItem item)“)
und wenn ich nun Alt+Enter klicke, dann gibt es mir eine
„Field to Import“-Auswahl mit zwei Möglichkeiten…
„styleable in R.MenuItem(android.support.v7.appcompat)“
oder
„styleable in R.MenuItem(com.user.shoppinglisthq)“
//anstelle von „User“ steht mein Benutzername
Da im Tutorial so viele Dateien eigens angelegt und verändert werden,
habe ich einfach mal die benutzerbezogene Auswahl getroffen, woraufhin AS mir
„import static com.user.shoppinglisthq.R.styleable.MenuItem;“
nach den anderen Imports einfügt..
..den Fehler behebt dies leider nicht :((
Auch die zweite Auswahl tut dies nicht..
Sämtliche Dateien sind in Ordnung,
nur die MainActivity.java hasst mich :/
Ich hoffe, hier kann mir geholfen werden…
Mein Hilfethread in einem Forum ist recht schnell ausgestorben :/
(an anderer Stelle ALT+Enter zu klicken und über das Menü „Setup JDK“
die 18er anstelle der 25er auszuwählen verschiebt die oben genannten Fehler
auf „.os.“ und „.view.“ vor den aktuell rot markierten Begriffen..)
Die übrigen auf Google auffindbaren Tipps wie „optimize imports on the fly“,
etc. abzuschalten brachte auch keinen Erfolg (waren standardmäßig aus…).
Auch AS oder PC neustarten, Projekt bereinigen oder Sync mit Gradle Files half nichts…
Ich drehe bald durch^^ lol
Android Studio Version: Android Studio 2.2.3
Build #AI-145.3537739, built on December 2, 2016
JRE: 1.8.0_76-release-b03 x86
JVM: OpenJDK Server VM by JetBrains s.r.o
Grüße, Chris
Author
Hallo Chris,
momentan kann ich mich aus Zeitgründen leider kaum den Kommentaren widmen, daher kommt meine Antwort so spät 🙁
Das hört sich nach einem sehr merkwürdigen Problem an.
Wenn du möchtest, kannst Du mir deine Projektdateien (den ganzen Android Studio Projektordner, aber OHNE die build-Unterordner) als ZIP per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Ich schaue dann mal, ob ich etwas herausfinden kann.
Viele Grüße, Chris
Hey Chris,
danke für Deine Antwort und entschuldige meine verspätete Meldung.
Ich hatte selbst einiges um die Ohren und konnte daher
nicht regelmäßig nach einer Antwort schauen.
Den Ordner habe ich eben versendet.
Ich bin mir ziemlich sicher, dass es nur ein Unwissenheitsfehler meinerseits ist,
da ich mit AndroidStudio noch nicht wirklich etwas am Hut hatte.
Vielen Dank für Deine Mühen
und frohe Ostern,
Chris
Pingback: Buchempfehlung: Android - Der schnelle und einfache Einstieg
Pingback: Testbericht: Video Training - Apps entwickeln mit Android Studio
Pingback: Android SQLite Tutorial - Teil 1: SQLite Projekt anlegen