android sqlite_wowomnom_Fotolia_85154667

Android SQLite Datenbank Tutorial – Teil 1: Android SQLite Projekt in Android Studio anlegen


In unserem mehrteiligen Android SQLite Tutorial werden wir eine Android App programmieren, die für das Speichern und Auslesen ihrer Daten eine SQLite Datenbank verwendet.

In dieser 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 Funktion der App ist sehr einfach. Der User kann in eine Einkaufsliste die zu kaufenden Produkte eintragen und welche Menge jeweils gekauft werden soll.

Die eingetragenen Daten werden in einer Android SQLite Datenbank gespeichert und beim Erzeugen der Liste wieder ausgelesen.

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

Da wir in diesem SQLite Tutorial mit dem hier erstellten Android Studio Projekt arbeiten, sollten die Lektionen unbedingt der Reihe nach absolviert und kein Arbeitsschritt übersprungen werden.

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

1. Erstellen des SQLite Datenbank Projekts in Android Studio

In diesem Abschnitt werden wir das Android Studio Projekt für unsere SQLite-App erstellen. Dazu navigieren wir zu dem Willkommensbildschirm von Android Studio.

Für das Erstellen unseres Android Projekts werden wir den New Project-Wizard von Android Studio verwenden.

Der Wizard ist ein Hilfsdialog, der uns durch den Erstellungsprozess unseres Projekts führt und uns die benötigten Einstellungen vornehmen lässt.

Der Erstellungsprozess besteht aus vier einfachen Arbeitsschritten.

Schritt 1: Mit einem Klick auf Start a new Android Studio project starten wir den New Project-Dialog, der uns durch die Erstellung des neuen Android Projekts führt.

android sqlite projekt erstellen

Schritt 1: Klick auf “Start a new Android Studio project” im Willkommensbildschirm von Android Studio

Wie auf dem oberen Bild zu erkennen ist, verwenden wir Android Studio in der Version 1.2.2. Die Version von Android Studio ist sehr wichtig, da sich von Zeit zu Zeit der Project-Wizard ändert und die Dialoge manchmal etwas anders aussehen können.

Schritt 2: Der New Project-Dialog erscheint, in dem wir Einstellungen für unser Projekt vornehmen können. Zuerst geben wir als Application name ShoppingListHQ und als Company Domain die eigene Webseite (z.B. programmierenlernenhq.de) an. Danach klicken wir auf Next.

android sqlite projekt name

Schritt 2: Details über das neue Android Studio SQLite Datenbank Projekt angeben

Schritt 3: Als nächsten Schritt geben wir den Minimum SDK vor. Der Minimum SDK legt fest, welche Android-Version mindestens auf dem mobilen Gerät installiert sein muss, damit unsere App darauf läuft. Wir wählen API15: Android 4.0.3 (IceCreamSandwich) aus und klicken anschließend auf Next.

android sqlite projekt api version

Schritt 3: Minimum-SDK für unsere SQLite App angeben

Schritt 4: Als letzten Schritt legen wir den grundsätzlichen Aufbau unserer App fest. Dazu wählen wir die erste Option Add No Activity aus, wodurch ein leeres Android Projekt von Android Studio angelegt wird. Mit einem Klick auf Finish schließen wir den Erstellungsprozess ab und lassen unser neues Projekt von Android Studio automatisch generieren.

android studio project no activity

Schritt 4: Die Android Projektdateien generieren lassen, dazu Add No Activity auswählen

Android Studio generiert jetzt unser Projekt. Dies kann einige Minuten dauern, daher ist Geduld gefragt. Nachdem Android Studio das Generieren abgeschlossen hat, wird das Android Projekt automatisch geöffnet.

1.1 Zur Projekt-Ansicht von Android Studio wechseln

Nachdem das Projekt von Android Studio erstellt wurde, sollten wir folgenden Bildschirm sehen:

android sqlite project start

Unser Android Projekt unmittelbar nachdem die Projektdateien generiert wurden

Nun wechseln wir als Nächstes in den Project-View (Projekt-Ansicht) von Android Studio. Dazu führen wir die folgenden Schritte aus:

  1. Mit der Maus auf den Menüeintrag View in der oberen Menüleiste klicken.
  2. Anschließend auf Tool Windows klicken.
  3. Und schließlich auf Project klicken, um die Projekt-Ansicht zu öffnen.
android sqlite project view

Zur Projekt-Ansicht (Project-View) von Android Studio wechseln

Danach werden wir die Darstellung der Projektstruktur ändern. Wir klicken dazu auf das Element Android oben links über der Baumstruktur. Zur Verdeutlichung haben wir einen roten Rahmen über das Android-Element gelegt und diesen mit 1 markiert.

Nachdem wir auf Android geklickt haben, öffnet sich ein Kontext-Menü. Hier klicken wir auf den ersten Eintrag Project und haben damit die Darstellung der Projektstruktur auf den Project-View umgestellt.

android sqlite project view change

Zur Projekt-Ansicht von Android Studio wechseln

Nun klappen wir unsere Projektdateien in der Projektleiste aus. Alle unsere Projektdateien befinden sich unter dem Eintrag app, wie in der folgenden Abbildung dargestellt:

android sqlite project start files

Wichtige Dateien unseres Android Studio Projekts

Wir sehen in der oberen Abbildung drei wichtige Dateien (wobei eine davon ein Package ist, um genau zu sein) unseres Android Projekts:

  1. Das Package (A) – Das Package unseres Projekts. Hier legen wir in späteren Teilen des Android Tutorials die Klassendateien ab. Es wird sich dabei um Activity-Klassen handeln.
  2. Das Manifest (B) – Die AndroidManifest.xml Datei. Sie ist die Schaltzentrale unserer Android App. In ihr geben wir unsere MainActivity bekannt und legen sie als Start-Activity fest.
  3. Die Gradle-Datei (C) – In der build.gradle Datei werden die wichtigen Einstellungen für den Erstellungsprozess unserer Android App verwaltet. Hierin befinden sich Angaben über die Zielplattform (targetSdkVersion), für die entwickelt werden soll, und die Minimalplattform (minSdkVersion), bis zu welcher unsere Android App kompatibel sein soll.

Wir werden nun in den nächsten Abschnitten Ressourcen-Ordner und Ressourcen-Dateien erstellen, die wir für die weiteren Teile des Android SQLite Tutorials benötigen werden. Sie bilden die Grundlage unserer Android App.

Wir werden die Ordner und Dateien der Reihe nach schrittweise anlegen. Die dafür notwendigen Arbeitsschritte sollten unbedingt wie beschrieben ausgeführt werden, da spätere Teile des Tutorials auf diesen Dateien und Ordnern aufbauen.

Am Ende dieser Lektion sollte eure Projektstruktur wie in der unteren Abbildung dargestellt aussehen:

android sqlite all files

Alle wichtigen Dateien unseres Android Studio Projekts am Ende dieser Lektion

Um dahin zu gelangen, werden wir nun die oben dargestellten Ordner und Dateien erstellen und die violett markierten Dateien überarbeiten.

2. Anlegen der String-Konstanten in der strings.xml Ressourcen-Datei

Als ersten Schritt werden wir zusätzliche String-Konstanten anlegen, die wir für die grafische Benutzeroberfläche unserer Android SQLite App verwenden werden.

Die String-Konstanten werden in der Ressourcen-Datei strings.xml definiert. Die Datei befindet sich in dem Verzeichnis res/values unseres Android Projekts.

Das Verwenden der strings.xml Datei ist besonders vorteilhaft, wenn die Android App in verschiedenen Sprachen veröffentlicht wird.

Wenn alle, für das User Interface benötigten, Strings an einer zentralen Stelle definiert werden, lässt sich die Anwendung sehr leicht lokalisieren. Es müssen nur die String-Konstanten übersetzt werden und schon ist die App auf eine andere Sprache umgestellt.

Diese nützliche Funktion wollen wir auch für unsere SQLite App nutzen. Dazu öffnen wir nun die strings.xml Datei mit einem Klick auf den entsprechenden Eintrag in der linken Projektleiste.

In der folgenden Abbildung haben wir die, von Android Studio frisch erzeugte, strings.xml Datei geöffnet:

android sqlite strings start

Die Ressourcen-Datei strings.xml zum Projektstart

Nun ersetzen wir den vorhandenen Quellcode der strings.xml Datei mit den folgenden Codezeilen:


In Android Studio sollte die strings.xml Datei nun folgendermaßen aussehen:

android sqlite strings end

Die Ressourcen-Datei strings.xml mit den vorgenommenen Änderungen

3. Definieren des Aussehens unserer SQLite App in der styles.xml Ressourcen-Datei

Auch wenn wir in diesem SQLite Tutorial nur eine Beispiel-Anwendung entwickeln, soll unsere Android App doch auch ein bisschen schick sein. Dazu nehmen wir einige Änderungen am Aussehen der App vor.

Generelle Vorgaben für das Format und Aussehen der grafischen Benutzeroberfläche von Android Apps werden in der styles.xml Datei festgelegt.

Die Datei befindet sich, wie die strings.xml Datei auch, in dem res/values Ordner unseres Android Studio Projekts.

Wir öffnen nun die Datei styles.xml im Editorfenster von Android Studio mit einem Klick auf ihren Dateinamen in der linken Projektleiste. Die folgende Abbildung zeigt den, von Android Studio erzeugten, Inhalt der Styles-Datei zu Projektbeginn:

android sqlite styles start

Die Ressourcen-Datei styles.xml zum Projektstart

Wir wollen jetzt die Farben der Action Bar verändern. Unsere App soll etwas freundlicher wirken, daher nehmen wir ein helles Blau als Grundfarbe für die Action Bar.

Dazu ersetzen wir den vorhandenen Quellcode der styles.xml Datei mit dem folgenden Code:


Die styles.xml Datei sollte in Android Studio jetzt wie folgt aussehen:

android sqlite styles end

Die Ressourcen-Datei styles.xml mit den vorgenommenen Änderungen

Viele weitere nützliche Informationen über die Styles-Datei findet ihr hier auf der Developer Webseite von Android.

3.1 Die Datei colors.xml löschen

Die Ressourcen-Datei colors.xml wird nun nicht mehr benötigt und kann daher gelöscht werden. Dazu gehen wir folgendermaßen vor:

  1. Mit der rechten Maustaste auf den colors.xml Eintrag in der Projektleiste klicken.
  2. Anschließend den Eintrag Delete... des Kontext-Menüs anklicken.
android sqlite colors delete

Löschen der Ressourcen-Datei colors.xml, da wir sie nicht mehr benötigen

Danach öffnet sich der Safe Delete-Dialog, den wir mit einem Klick auf den OK-Button bestätigen:

android studio project colors dialog

Bestätigen des Löschvorgangs mit Klick auf OK

Die Datei colors.xml sollte nun bei euch gelöscht und nicht mehr in der Projektleiste aufgeführt sein.

4. Erstellen der dimens.xml Ressourcen-Datei

Nun, als letzten Arbeitsschritt in dem Ressourcen-Ordner values, legen wir die Ressourcen-Datei dimens.xml an. In ihr werden Abstandsangaben global gespeichert.

Um die Datei dimens.xml anzulegen, gehen wir wie folgt vor:

  1. Mit der rechten Maustaste auf den Ordner values in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Values resource file klicken.
android sqlite dimens create

Erstellen der Ressourcen-Datei dimens.xml in Android Studio

Als Nächstes öffnet sich der New Values Resource File-Dialog, in dem wir den Namen der Ressourcen-Datei vorgeben. Wir geben in das Textfeld als Namen dimens.xml ein und bestätigen mit OK.

android studio project dimens name

Dateinamen für die neue Ressourcen-Datei festlegen.

In die neu erstellte Datei fügen wir den folgenden Quellcode ein:


Mit den oberen Zeilen legen wir globale Werte für den horizontalen und vertikalen Abstand in unserer Android App fest. Auf diese hier definierten Konstanten werden wir später von der Layout-Datei aus zugreifen.

In Android Studio sollte die dimens.xml Ressourcen-Datei nun wie folgt aussehen:

android sqlite dimens code

Die neu angelegte Ressourcen-Datei dimens.xml mit den vorgenommenen Änderungen

Mit diesem letzten Arbeitsschritt in diesem Abschnitt haben wir die Vorbereitungen am values-Ordner abgeschlossen.

Im nächsten Abschnitt werden wir eine Menü-Ressource für unsere Android App anlegen und darin einen Menüeintrag definieren.

Wir werden in diesem Android Tutorial eine App programmieren, die über ein Options Menu verfügt. Damit wir unserer Android App dieses Menü hinzufügen können, müssen wir das Menü in einer Menü-Ressourcendatei definieren.

Um dies zu tun, sind die folgenden beiden Arbeitsschritte notwendig:

  1. Anlegen des Ordners menu – In dem Menu Resource-Ordner werden wir die Layout-Datei des Menüs unserer Android App speichern.
  2. Erstellen der Datei menu_main.xml – Diese Menu Resource-Datei wird die Einträge für das Menü unserer MainActivity enthalten. Wir werden sie als Basis des Options Menu unserer App nutzen.

Beginnen wir nun mit dem ersten Arbeitsschritt und legen den menu-Ordner an.

5.1 Anlegen des menu-Ordners in Android Studio

Um eine Menu Resource-Datei anzulegen, muss vorher ein passender Ordner in dem Android Projekt vorhanden sein. Diesen werden wir zuerst anlegen. Dazu führen wir folgende Schritte durch:

  1. Mit der rechten Maustaste auf den Ordner res in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Android resource directory klicken.
android sqlite menu folder

Erstellen des Menu Ressourcen-Ordners menu in Android Studio

Anschließend öffnet sich der New Resource Directory-Dialog. Wir nehmen in ihm folgende Einstellungen vor:

  • Directory name: menu
  • Resource type: menu
  • Source set: main

Weitere Einstellungen nehmen wir nicht vor und bestätigen den Dialog mit einem Klick auf den OK-Button.

Der New Resource File Dialog mit den einzutragenden Einstellungen

Der New Resource Directory Dialog mit den einzutragenden Einstellungen

Nun legt Android Studio das Ressourcen-Verzeichnis für unsere Menü-Ressourcendateien automatisch an.

5.2 Erstellen der menu_main.xml Ressourcen-Datei

Als nächsten Schritt erstellen wir die Ressourcen-Datei menu_main.xml, die Informationen über die Einträge unseres Options Menu enthält. Dazu führen wir die folgenden Schritte aus:

  1. Mit der rechten Maustaste auf den eben erstellten Ordner menu in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Menu resource file klicken.
android sqlite menu file

Erstellen der Menü Ressourcen Datei menu_main.xml in Android Studio

Danach öffnet sich der New Menu Resource File-Dialog, in dem wir als Namen für unsere Menü Ressourcendatei menu_main.xml eingeben.

android studio project menu filename

Dateinamen für die neue Menü Ressourcen Datei festlegen.

Wir öffnen nun die neu erstellte Menü Ressourcendatei menu_main.xml im Editorfenster und fügen den folgenden Quellcode ein:


Mit dem oberen Quellcode definieren wir ein Menü mit einem Menüeintrag. Der Menüeintrag besitzt eine id und einen title. Den Wert für den title lesen wir aus der strings.xml Ressourcendatei aus.

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

android sqlite menu code

Die Menü Ressourcen Datei menu_main.xml mit den vorgenommenen Änderungen

Somit haben wir nun die Voraussetzungen für ein Menü geschaffen. Wir werden später diese Menü Ressourcendatei in der MainActivity nutzen und mit ihr das Options Menu füllen.

6. Erstellen der MainActivity und ihrer Layout-Datei

Wir werden nun die MainActivity anlegen. Da eine Activity eine Layout-Datei benötigt, über die ihr Aussehen definiert wird, müssen wir vorher eine solche Layout-Datei für unsere Activity anlegen. Diese Datei muss in einem Resource Directory liegen, welches wir auch in diesem Abschnitt anlegen werden.

Somit besteht das Anlegen der MainActivity aus den folgenden drei Arbeitsschritten:

  1. Anlegen des Ordners layout – Wir legen einen Ressourcen-Ordner für die Layout-Datei der Activity an.
  2. Erstellen der Layout-Datei activity_main.xml – In dem erstellten Ordner lassen wir die Layout-Datei activity_main.xml erstellen und definieren in ihr das Aussehen unserer MainActivity.
  3. Erstellen der Klassendatei MainActivity.java – Nun können wir die Activity in dem Java Package unseres Android Projekts anlegen lassen und sie mit Quellcode füllen.

Beginnen wir nun mit dem ersten Arbeitsschritt.

6.1 Anlegen des layout-Ordners in Android Studio

Der layout-Ordner enthält die Layout-Dateien der Activities und Fragmente der Android Anwendung. Über die Layout-Dateien wird das Aussehen der Activities und Fragmente definiert. Wir werden nun einen Layout Ressourcen-Ordner anlegen.

Dazu gehen wir folgendermaßen vor:

  1. Mit der rechten Maustaste auf den Ordner res in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Android resource directory klicken.
android sqlite layout folder

Erstellen des Layout Ressourcen-Ordners layout in Android Studio

Anschließend öffnet sich der New Resource Directory-Dialog. Wir nehmen in ihm folgende Einstellungen vor:

  1. Directory name: layout
  2. Resource type: layout
  3. Source set: main

Weitere Einstellungen nehmen wir nicht vor und bestätigen den Dialog mit einem Klick auf den OK-Button.

android studio project layout directory

Der New Resource Directory Dialog mit den einzutragenden Einstellungen für den layout-Ordner

Nun legt Android Studio das Ressourcen-Verzeichnis für unsere Layout-Ressourcendateien automatisch an.

6.2 Erstellen der activity_main.xml Ressourcen-Datei

Als nächsten Schritt erstellen wir die Ressourcen-Datei activity_main.xml, die Informationen über das Aussehen unserer Activity enthält. Dazu führen wir die folgenden Schritte aus:

  1. Mit der rechten Maustaste auf den eben erstellten Ordner layout in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Layout resource file klicken.
android sqlite layout file

Erstellen der Layout Ressourcen Datei activity_main.xml in Android Studio

Danach öffnet sich der New Layout Resource File-Dialog, in dem wir als Namen für unsere Layout Ressourcendatei activity_main.xml eingeben. Das Root element belassen wir bei LinearLayout.

android studio project layout activity name

Dateinamen für die neue Layout Ressourcen Datei festlegen.

Wir öffnen nun die neu erstellte Layout Ressourcendatei activity_main.xml im Editorfenster. Um den Quelltext zu sehen, müssen wir unten im Editorfenster den Tab Text anklicken. Nachdem wir das getan haben, werden wir das Layout unserer SQLite-App neu definieren.

Unsere Android App soll eine virtuelle Einkaufsliste werden. Dazu benötigen wir zwei EditText-Widgets (Produkt und Menge) und einen Hinzufügen-Button, mit dessen Hilfe die eingetragenen Werte in die SQLite Datenbank geschrieben werden. Außerdem benötigen wir eine Liste, die alle gespeicherten Einträge anzeigt.

Um das eben besprochene Layout zu erstellen, muss die Datei activity_main.xml, die sich in dem Ordner res/layout befindet, überarbeitet werden.

Wir löschen den generierten Layout-Code komplett und ersetzen ihn mit folgendem Quellcode:


Unsere UI-Elemente sind in einem LinearLayout angeordnet, welches selbst ein LinearLayout-Element enthält und einen ListView mit dem wir die Einkaufslisteneinträge anzeigen.

In dem eingeschlossenen LinearLayout sind die beiden EditText-Widgets und der Hinzufügen-Button angeordnet. Die Orientierung dieses Layouts ist horizontal. Das erste EditText-Feld ist für die Eingabe der gewünschten Menge vorgesehen, das Zweite für den Produktnamen.

Mit einem Klick auf den Button sollen die eingetragenen Werte in die SQLite Datenbank gespeichert werden.

Sehr detaillierte Informationen über die verwendeten Layout-Elemente findet ihr auf der Android Developer Seite unter folgenden Links:

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

android sqlite layout code

Der generierte Code wurde komplett gelöscht und durch diesen XML-Code ersetzt

6.3 Erstellen der Klassendatei MainActivity.java

Nun werden wir die Klassendatei MainActivity.java anlegen.

Die Activity legen wir folgendermaßen an:

  1. Mit der rechten Maustaste auf das Package de.programmierenlernenhq.shoppinglisthq klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Java Class klicken.
android sqlite activity create

Erstellen der Klassendatei MainActivity.java in Android Studio

Anschließend öffnet sich der Create New Class-Dialog, in dem wir als Klassennamen MainActivity eingeben. Den Wert für Kind lassen wir auf Class stehen. Den Dialog bestätigen wir mit Klick auf OK.

android studio project activity classname

Klassennamen für die Activity-Klasse festlegen.

Android Studio legt nun automatisch die neue Java Klasse an. Den erzeugten Quellcode werden wir durch eigenen Code ersetzen.

Dazu öffnen wir die Klassendatei MainActivity.java und fügen den folgenden Quellcode ein:


Die Activity-Klasse macht noch nicht sehr viel. Sie verfügt über drei Callback-Methoden, in denen das Layout der Activity geladen und das Options Menu eingerichtet wird.

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

android sqlite activity code

Die Klasse MainActivity.java mit den vorgenommenen Änderungen

Jetzt haben wir die Basis für unsere Android SQLite App gelegt. Wir haben eine Activity erstellt und ihr ein Layout zugewiesen. Außerdem haben wir der Activity ein Options Menu zugefügt, welches wir vorher über die entsprechende Ressourcen-Datei definiert hatten.

Zusätzlich haben wir allgemeine Ressourcen-Dateien angelegt bzw. überarbeitet, auf die wir im Laufe der nächsten Lektionen dieses Android Tutorials immer wieder zugreifen werden.

Das alles hört sich sehr gut an, aber zum Starten unserer Android App fehlt noch ein wichtiger Schritt. Wir müssen die MainActivity in der Schaltzentrale unserer App bekannt machen. Dies werden wir im nächsten Abschnitt vornehmen.

7. Anpassen der AndroidManifest.xml Datei

Bevor wir unsere Android App ausführen können, müssen wir die Activity bekannt geben, die zum Start ausgeführt werden soll. Dafür verantwortlich ist die AndroidManifest.xml Datei. Sie ist die Schaltzentrale unserer Android Anwendung.

Wir öffnen nun die AndroidManifest.xml Datei im Editorfenster. Beim Erstellen unseres Android Projekts hat Android Studio bereits den Namen der Application eingetragen und das AppTheme festgelegt.

Wir werden nun den Quellcode der AndroidManifest.xml Datei mit dem folgenden Code ersetzen:


Jetzt haben wir unsere MainActivity bekannt gemacht und für sie einen intent-filter definiert. Über Intents werden in Android Activities gestartet.

In diesem Fall wurde unsere MainActivity als Start-Activity festgelegt, die aufgerufen werden soll, sobald unsere Android App gestartet wird.

Die AndroidManifest.xml Datei sollte in Android Studio nun wie folgt aussehen:

android sqlite manifest

Die AndroidManifest.xml Datei mit den vorgenommenen Änderungen

Jetzt haben wir alle notwendigen Änderungen an den generierten Projektdateien vorgenommen und die Vorbereitungen an unserer Android SQLite App abgeschlossen. Bevor wir nun im nächsten Teil des SQLite Datenbank Tutorials mit dem wirklichen Programmieren beginnen, sollten wir die Anwendung noch einmal auf dem Android Gerät testen.

Dies werden wir im nächsten Abschnitt ausführen.

8. Installieren und Starten der SQLite App

Alle notwendigen Änderungen an den Quelltexten unseres Android Projekts sind vorgenommen. Nun wollen wir unsere App 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.1 Testen des Layouts unserer Android SQLite App

Sobald unsere App gestartet ist, können wir das Layout der grafischen Benutzeroberfläche überprüfen.

Wenn alle Änderungen an den Projektdateien korrekt ausgeführt wurden, sollte die Action Bar blau gefärbt sein. Direkt unter der Action Bar sollten die beiden EditText-Felder mit dem Hinzufügen-Button angeordnet sein.

Unter diesen drei Elementen befindet sich der ListView, der momentan noch ohne Inhalt und daher für uns nicht sichtbar ist.

In der unteren Abbildung ist das Layout unserer SQLite App dargestellt.

android sqlite app

Unsere SQLite Datenbank App in der ersten Version (nur Layout)

Die App sollte auch bei euch, wie in der Abbildung dargestellt, aussehen. Jetzt sind alle Vorbereitungen abgeschlossen und die SQLite Datenbank kann in der nächsten Lektion in unsere Android Anwendung integriert werden.

Zusammenfassung

In dem ersten Teil des Android SQLite Tutorials haben wir die notwendigen Vorbereitungen an unserer Beispiel-App vorgenommen.

Als Erstes haben wir das Projekt in Android Studio mit Hilfe des New Project-Wizard angelegt. Anschließend haben wir die benötigten String-Konstanten in der strings.xml Datei definiert und Anpassungen an dem Erscheinungsbild unserer App in der styles.xml Datei vorgenommen.

Wir haben eine neue Ressourcen-Datei, die dimens.xml, angelegt und eine Menü Ressource für das Options Menu unserer MainActivity erstellt.

Danach haben wir das Layout unserer SQLite App definiert, so dass die User später Einträge in die SQLite Datenbank mit Hilfe der grafischen Benutzeroberfläche vornehmen können. Abschließend haben wir die Android App auf einem Android Gerät ausgeführt und dabei das Layout überprüft.

In der nächsten Lektion des Android SQLite Tutorials werden wir SQLite näher kennenlernen und die, für das Arbeiten mit Datenbanken, benötigten Klassen anlegen und besprechen.


Comments 7

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

  2. Daniel Buchauer

    Hallo liebes Programmieren Lernen Team,
    ich habe eine wichtige Frage.
    Ich würde gerne eine einzelne Reihe der Datenbank ausgeben, indem ich
    die id der Reihe in ein Textfeld eingebe. Ich habe es mit dieser Methode versucht:

    die ich in die Klasse ShoppingMemoDataSource eingebunden habe. Leider funktioniert dies nicht nicht wirklich und ich weiß nicht ganz wie man das ganze in der Main Activity anzeigen lassen kann.

    1. Post
      Author
      Chris

      Hallo Daniel,

      schwer zu sagen woran es liegt ohne den gesamten Quellcode und Debugger. Wenn Du möchtest, kannst Du uns Deine Projektdateien als ZIP per E-Mail zusenden. Wir werde dann mal drüber schauen und können vielleicht den Fehler finden. Die E-Mail Adresse kannst Du im Impressum finden.

      Viele Grüße, Chris

    1. Post
      Author
  3. Ekke

    Danke für das tolle Tutorial.
    Eine Frage: Wie verlässt man das Programm, so dass die OnPause() Methode der DB aufgerufen wird? Klickt man nur auf das “x” oben links außerhalb des Layouts geschieht das nicht mit der Folge, dass ich regelmäßig meine Daten aus der DB verliere.

    1. Post
      Author
      Chris

      Hallo Ekke,

      die onPause() Methode der entsprechenden Activity wird vom Android System immer vor Programmende aufgerufen. Dabei spielt es keine Rolle wie die Activity (das Programm) verlassen wird. Den genauen Ablauf habe ich hier beschrieben: Der Activity Lifecycle in Android.

      Das Zwischenspeichern der Daten bzw. der gewünschte Datenbankzugriff müsste daher in der onPause() Methode der entsprechenden Activity implementiert werden.

      Viele Grüße, Chris

Hinterlasse eine Antwort

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