Programmier Tutorial: Apps für Android entwickeln – Teil 29: Daten in einer Datei speichern und wieder auslesen

---

Auf diese Weise bleiben die ListView-Einträge über die Lebenszeit unserer Android App (und ihrer Activity) hinaus erhalten. Da die Daten persistent in der Datei gespeichert sind, können wir den ListView-Inhalt beim Neuerstellen der MainActivity vollständig wiederherstellen.

Im theoretischen Teil dieser Lektion werden wir beschreiben, auf welche Arten Anwendungs- und Nutzerdaten in Android gespeichert werden können. Dabei werden wir erfahren, wie Daten in einer Datei persistent im Gerätespeicher abgelegt und später aus der Datei wieder ausgelesen werden können.

Danach werden wir im praktischen Teil das Speichern und Laden des ListView-Inhalts implementieren. Dafür werden wir zuerst die beiden Hilfsmethoden saveQuoteListInFile() und restoreQuoteListFromFile() in der Utility-Klasse definieren. Wir werden sie für das persistente Speichern des ListView-Inhalts in einer Datei und für das Auslesen der gespeicherten Daten aus der Datei verwenden.

Anschließend werden wir einige Anpassungen an der MainActivity-Klasse vornehmen. In der onStop() Methode werden wir den ListView-Inhalt auslesen und mit Hilfe der saveQuoteListInFile() Hilfsmethode in einer Datei auf dem internen Speicher des Android Geräts abspeichern lassen. In der createQuoteList() Methode, die von der onCreate() Methode aufgerufen wird, werden wir die gespeicherten Daten aus der Datei wieder auslesen und dem ListView als Datenquelle zuweisen.

Abschließend werden wir unsere Android App im Emulator auf einem Android Virtual Device ausführen und prüfen, ob der Inhalt des ListViews persistent in einer Datei gespeichert und korrekt aus der Datei wiederhergestellt wird.

1. Daten persistent in in Android speichern

In Android können Anwendungsdaten auf verschiedene Arten gespeichert werden. Welche Speicherlösung man für die eigene Android App wählt, ist von den spezifischen Anforderungen der App abhängig. So muss bei der Auswahl bspw. bedacht werden, wie viel Speicherplatz für die Daten benötigt wird und ob die Daten nur für die eigene Anwendung oder auch für andere Apps zugänglich sein sollen.

Die Android Plattform stellt dazu die folgenden Lösungen zum Speichern von Daten bereit:

• Internal File Storage – Der interne Dateispeicher wird für das Speichern privater App-Daten verwendet. Die Daten werden in Dateien im Dateisystem des Geräts, also dem Gerätespeicher, gespeichert. Der interne Speicher ist der ideale Ort für das Speichern von Anwendungdaten, auf die der Benutzer keinen direkten Zugang benötigt.

  Das Android System stellt für jede App ein privates Verzeichnis auf dem Gerätespeicher bereit, in dem die App ihre Daten frei verwalten kann. Wenn der Benutzer die Android App deinstalliert, werden alle von der App auf dem Gerätespeicher gespeicherten Dateien entfernt. Daher sollten auf dem internen Speicher niemals Daten gespeichert werden, von denen der Benutzer erwartet, dass sie nach Deinstallieren der App bestehen beleiben, wie bspw. Videos.

• External File Storage – Der externe Dateispeicher wird für das Speichern von öffentlich zugänglichen Dateien, wie vom Benutzer geteilten Videos und Fotos, verwendet. Die Daten werden in Dateien im freigegebenen externen Dateisystem, bspw. auf einer Speicherkarte, gespeichert.

  Dateien, die auf dem externen Speicher gespeichert wurden, können von jedem ausgelesen und verändert werden, wenn der Benutzer das Android Gerät für den USB Datentransfer am Computer freigibt. Für vom Benutzer freigegebene Dateien ist dies von Vorteil, da so der Benutzer bspw. Fotos und Videos einfach auf seinen Computer kopieren kann. Für private Dateien ist dies ein großes Sicherheitsrisiko. Daher sollte vom Entwickler gut überlegt werden, welche Daten von der App extern gespeichert werden sollen.

  Wenn die Android App vom Benutzer deinstalliert wird, bleiben die auf dem externen Speicher gespeicherten Dateien erhalten. Dies ist besonders wichtig für vom Benutzer erstellte Daten wie Fotos und Videos sowie für heruntergeladene Dokumente.

• Shared Preferences – In den Shared Preferences können primitive Daten (boolean, float, int, long and string) in Form von Schlüssel-Wert Paaren (key-value pairs) gespeichert werden. Die Daten sind privat und daher nur für die eigene App zugänglich. Das Lesen und Schreiben der Schlüssel-Wert Paare wird von der SharedPreferences API geregelt. Die Schlüssel-Wert Paare werden in XML-Dateien persistent gespeichert und bleiben dadurch auch bestehen, wenn die App endgültig beendet wird.

  Der Name der API „shared preferences“ ist ein bisschen ungünstig gewählt, da er vermuten lässt, dass nur user preferences, also Benutzereinstellungen, damit gespeichert werden können. In der Praxis ist es aber so, dass jede Art von einfachen Daten mit der SharedPreferences API persistent gespeichert werden kann.

• Databases – Android bietet vollständige Unterstützung für SQLite-Datenbanken, die für das Speichern privater, strukturiertet Daten verwendet werden können. Auf von der Anwendung erstellte Datenbanken kann nur von der eigenen App zugegriffen werden.

• Backup Service – Die Android App kann auch einen Sicherungsdienst (backup service) nutzen, durch den Benutzer Daten in der Cloud speichern und sie auf verschiedenen Geräten synchronisieren und wiederherstellen können.

Wir werden als persistente Speicherlösung für unsere Anwendung den Internal File Storage verwenden und den Inhalt des ListViews unserer Android App in einer Datei auf dem internen Gerätespeicher speichern. Die so gespeicherten Daten werden dann nur für unsere eigene Anwendung zugänglich sein. Auch der Benutzer selbst kann nicht auf die entsprechende Datei zugreifen. Was auch so beabsichtigt ist.

1.1 Auf Dateien des internen Speichers des Android Geräts zugreifen

Das von der Android Plattform verwendet Dateisystem ist Festplatten-basierten Dateisystemen anderer Plattformen sehr ähnlich. Für das Arbeiten mit den Dateien ist die File API verantwortlich. Mit ihr lassen sich auch große Datenmengen in Dateien schreiben und wieder aus ihnen auslesen. Sie ist darauf optimiert die Daten in einem Fluss zu verarbeiten, also vom Anfang bis zum Ende der Daten ohne Sprünge.

Der genaue Ort an dem die Dateien von der File API gespeichert werden, wird von dem Package-Namen der App vorgegeben und variiert je nach Android Gerät. Daher sollte der Dateizugriff nicht mit absoluten Pfaden erfolgen, sondern stattdessen spezielle Methode verwendet werden, die den Pfad zu den internen Dateien vom Android System erhalten.

Hinweis: Der absolute Pfad zur Datei kann mit Hilfe der getAbsolutePath() Methode der File-Klasse an die Konsole ausgegeben werden. Anschließend kann im Device File Explorer Tool Window von Android Studio zu der Datei navigiert werden. Dies ist aber nur möglich, wenn die App auf einem Android Virtual Device im Emulator ausgeführt wird.

Im Gegensatz zu dem externen Speicher benötigt eine Android App keine zusätzlichen System-Berechtigungen, um auf den internen Speicher lesend und schreibend zugreifen zu dürfen.

1.1.1 Daten in einer Datei auf den internen Speicher speichern

Das Android System stellt für jede App ein privates Verzeichnis auf dem internen Speicher des Android Geräts zur Verfügung, in welchem die App Dateien frei verwaltet kann. Da der Verzeichnispfad je nach Android Gerät variiert, kann er nicht pauschal angegeben werden. Dies ist aber auch nicht notwendig, da der absolute Verzeichnispfad mit der Methode getFilesDir() zur Laufzeit vom Android System angefordert werden kann.

Hat man den absoluten Pfad zum privaten Verzeichnis der App angefordert, kann mit dem File() Konstruktor sehr einfach eine neue Datei in diesem privaten Verzeichnis erstellt werden. Der Konstruktor benötigt dafür nur den absoluten Verzeichnispfad und den Namen der zu erstellenden Datei:

String filename = "Zitatdaten.txt";
File file = new File(context.getFilesDir(), filename);

Die Methode getFilesDir() muss auf einem Context-Objekt, wie es bspw. eine Activity-Instanz ist, aufgerufen werden. Sie liefert den absoluten Pfad, der zu dem privaten Verzeichnis der Android App führt, zurück. In die so erstellte Datei können dann beliebige Daten geschrieben werden. Es sollte aber unbedingt darauf geachtet werden, die Datenmenge möglichst gering zu halten, da manche Android Geräte über nur sehr wenig internen Speicherplatz verfügen.

Der eben beschriebene Weg eine Datei in Android zu erstellen, ist das klassische Vorgehen. Es gibt aber noch einen alternativen Weg, auf den Dateien in Android direkt beim Erstellen mit Daten gefüllt werden können. Diesen werden wir nun ausführlicher beschreiben, da er die bevorzugte Art ist, um Dateien in den interen Speicher eines Android Geräts zu speichern.

Dazu muss ein FileOutputStream-Objekt mit der openFileOutput() Methode, welche auf einer Context-Instanz aufgerufen wird, erzeugt werden. Das FileOutputStream-Objekt kann die zu schreibenden Daten direkt in einer Datei in das private Verzeichnis der App abspeichern. Den absoluten Pfad zum internen Verzeichnis benötigt es dafür nicht.

Mit folgendem Quellcode wird ein beliebiger Text in einer Datei in das private App-Verzeichnis abgespeichert:

public void saveFile(Context context) {

    String filename = "Zitatdaten.txt";
    String data = "Daten, die in die Datei geschrieben werden sollen.";

    FileOutputStream fileOutputStream;
    try {
        fileOutputStream = context.openFileOutput(filename, context.MODE_PRIVATE);
        fileOutputStream.write(data.getBytes());
        fileOutputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Der openFileOutput() Methode muss eine file mode Parameter übergeben werden, über den festgelegt wird wie und von wem auf die zu erstellende Datei zugegriffen werden kann. Dieser Parameter muss ab Android 7.0 (API level 24) MODE_PRIVATE sein, wodurch die Datei nur für unsere eigene Android App zugänglich ist.

Die beiden anderen file modes MODE_WORLD_READABLE und MODE_WORLD_WRITEABLE sind mittlerweile veraltet und führen zu einer SecurityException sollten sie dennoch verwendet werden.

Wir werden den eben beschriebenen Quellcode später im praktischen Teil dieser Lektion wiederverwenden und den Inhalt unseres ListViews mit Hilfe der openFileOutput() Methode in eine Datei in dem privatem Verzeichnis unserer App abspeichern lassen. Auf die erstellte Datei wird dann nur unsere App zugreifen können. Für andere Apps und selbst für den Benutzer wird die erstellte Datei nicht zugänglich sein.

1.1.2 Daten aus einer Datei des internen Speichers auslesen

Das Auslesen von Daten aus einer Datei des internen Speichers verläuft in umgekehrter Richtung zum Speichern. Mit der openFileInput() Methode wird auf eine, sich im privaten Verzeichnis der App befindende, Datei lesend zugegriffen. Ihr muss dazu nur der Name der auszulesenden Datei übergeben werden.

Mit folgendem Quellcode wird eine Text-Datei, die sich im privaten App-Verzeichnis befindet, ausgelesen:

public String loadFile(Context context) {

    String filename = "Zitatdaten.txt";
    String data;

    FileInputStream fileInputStream;
    try {
        fileInputStream = context.openFileInput(filename);
        InputStream stream = new BufferedInputStream(fileInputStream);
        data = convertStreamToString(stream);    
        fileInputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }

    return data;
}

Die openFileInput() Methode, welche auf einer Context-Instanz aufgerufen wird, erzeugt ein FileInputStream-Objekt. Dazu muss ihr nur der Name der auszulesenden Datei übergeben werden. Der Pfad zum internen Speicher der App ist ihr bereits bekannt. Das erzeugt FileInputStream-Objekt enthält den Inhalt der Text-Datei in Form eines Datenstroms.

Das InputStream-Objekt muss nun nur noch in einen String umgewandelt werden. Dazu kann die convertStreamToString() Methode verwendet werden, die von uns bereits in einer vorherigen Lektion in der Utility-Klasse implementiert worden ist. Abschließend wird die ausgelesene Zeichenkette an den Aufrufer zurückgeliefert.

Wir werden nun die beiden gerade beschriebenen Methoden in unserer App in etwas abgewandelter Form in der Utility-Klasse implementieren. Durch sie werden wir den ListView-Inhalt persistent in einer Datei speichern und anschließend wieder aus der Datei auslesen lassen.

2. Implementieren der benötigten Hilfsmethoden in der Utility-Klasse

Wir kommen nun zum praktischen Teil dieser Lektion, in welchem wir das Speichern des ListView-Inhalts in eine Datei und anschließende Auslesen der Daten aus der Datei implementieren. Dazu werden wir in diesem Abschnitt die beiden Hilfsmethoden saveQuoteListInFile() und restoreQuoteListFromFile() in der Utility-Klasse definieren.

Die Hilfsmethode werden wir später von der MainActivity-Klasse aus verwenden, wenn wir das Speichern des ListView-Inhalts in einer Datei und das Auslesen der gespeicherten Daten veranlassen.

Wir werden nun die beiden Methoden saveQuoteListInFile() und restoreQuoteListFromFile() in der Utility-Klasse implementieren. Dazu öffnen wir die Klassendatei Utility.java im Editor von Android Studio, indem wir doppelt auf ihren Dateinamen im Project Tool Window klicken. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.zitate unseres Projekts.

In dem unteren Quellcode der Utility.java Datei sind die erforderlichen Maßnahmen bereits durchgeführt und die eingefügten Codezeilen grau markiert worden:

Hinweis: Der untere Quellcode ist Teil des geschützten Bereichs von ProgrammierenLernen^HQ. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte.
Erfahre mehr über unsere Android Online-Kurse.

Im oberen Quellcode der Utility-Klasse sind die beiden neuen Methoden und die vier benötigten Import-Anweisungen bereits hinzugefügt worden. Die eingefügten Zeilen sind grau markiert.

In den Zeilen 18 bis 21 werden die vier benötigten Klassen mittels Import-Anweisungen innerhalb der Utility-Klasse sichtbar gemacht, so dass wir sie ohne den Namen ihres Packages verwenden können.

In Zeile 43 wird die Konstante FILENAME_QUOTE_DATA definiert. Sie enthält den Dateinamen der im privaten App-Verzeichnis zu erstellenden Datei.

In den Zeilen 199 bis 220 und 222 bis 246 werden die beiden neuen Methoden saveQuoteListInFile() und restoreQuoteListFromFile() definiert. Wir werden beide Hilfsmethoden nun ausführlich betrachten und dabei beschreiben, wie die Daten in die Datei persistent geschrieben bzw. aus dieser ausgelesen werden.

Die saveQuoteListInFile() Methode

Wie bereits weiter oben erwähnt, wird in den Zeilen 199 bis 220 der Utility-Klasse die saveQuoteListInFile() Methode definiert. Ihre Aufgabe ist das Speichern einer Liste von Quote-Objekten in einer Datei in das private Verzeichnis unserer Android App.

Wie sie sie dies ausführt, werden wir nun genauer betrachten. Die Methode ist daher zur Übersichtlichkeit an dieser Stelle nochmals aufgeführt:

public static void saveQuoteListInFile(Context context, List<Quote> quoteList) {

    String jsonString = createJSONStringFromQuoteList(quoteList);
    FileOutputStream fileOutputStream = null;
    try {
        fileOutputStream = context.openFileOutput(FILENAME_QUOTE_DATA, Context.MODE_PRIVATE);
        fileOutputStream.write(jsonString.getBytes());
    } catch (FileNotFoundException e) {
        Log.e(TAG, "FileNotFoundException: " + e.getMessage());
    } catch (IOException e) {
        Log.e(TAG, "IOException: " + e.getMessage());
    }
    finally {
        if (fileOutputStream != null) {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                Log.e(TAG, "IOException: " + e.getMessage());
            }
        }
    }
}

Die saveQuoteListInFile() Methode besitzt zwei Parameter. Der erste Parameter ist vom Datentyp Context. Ihm wird der Verweis auf die MainActivity-Instanz übergeben. Über ihn wird der Aufruf der openFileOutput() Methode ausgeführt, wodurch das fileOutputStream-Objekt erzeugt wird. Der zweite Parameter ist vom Datentyp List<Quote> und nimmt eine Quote-Liste, die alle ListView-Einträge enthält, in sich auf.

In Zeile 3 wird die Quote-Liste ausgelesen und in einen JSON-String umgewandelt. Dazu wird die createJSONStringFromQuoteList() Methode benutzt. Der so erstellte JSON-String besitzt das vom Webserver verwendete Format, dadurch kann er später beim Auslesen wieder leicht in eine Quote-Liste umgewandelt werden.

Innerhalb des try-Blocks in den Zeilen 6 und 7 wird das fileOutputStream-Objekt mit Hilfe der openFileOutput() Methode erzeugt. Ihr wird dazu der Name der zu erstellenden Datei und als file mode die Konstante Context.MODE_PRIVATE übergeben.

Das fileOutputStream-Objekt benötigt für das Erstellen der privaten Datei keine weiteren Eingaben und legt daraufhin die Datei mit dem Namen Zitatdaten.txt im privaten Verzeichnis unserer App auf dem internen Speicher der Android Geräts an. In der Datei wird der JSON-String, der die ListView-Einträge im JSON-Format enthält, mit Hilfe der write() Methode Byte-weise geschrieben.

Im finally-Block in Zeile 16 wird der FileOutputStream schließlich wieder geschlossen. Die Daten sind nun in der Datei Zitatdaten.txt im App-Verzeichnis auf dem Gerätespeicher persistent gespeichert. Dort bleiben sie solange bestehen, bis der Benutzer unserer App von seinem Android Gerät deinstalliert.

Die restoreQuoteListFromFile() Methode

Die restoreQuoteListFromFile() Methode wird in den Zeilen 222 bis 246 der Utility-Klasse definiert. Ihre Aufgabe ist das Auslesen der Datei Zitatdaten.txt und Umwandeln der darin enthaltenen JSON-Daten in eine Quote-Liste. Die Quote-Liste wird anschließend von ihr an den Aufrufer zurückgegeben.

Wie dies von ihr realisiert wird, werden wir nun genauer betrachten. Die Methode ist daher zur Übersichtlichkeit an dieser Stelle nochmals aufgeführt:

public static List<Quote> restoreQuoteListFromFile(Context context) {

    String jsonString = "";
    FileInputStream fileInputStream = null;
    try {
        fileInputStream = context.openFileInput(FILENAME_QUOTE_DATA);
        InputStream stream = new BufferedInputStream(fileInputStream);

        jsonString = convertStreamToString(stream);
        Log.i(TAG, "JSON-String aus Datei gelesen: " + jsonString);
    } catch (FileNotFoundException e) {
        Log.e(TAG, "FileNotFoundException: " + e.getMessage());
    }
    finally {
        if (fileInputStream != null) {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                Log.e(TAG, "IOException: " + e.getMessage());
            }
        }
    }

    return createQuotesFromJSONString(jsonString);
}

Die restoreQuoteListFromFile() Methode besitzt einen Parameter vom Datentyp Context. Ihm wird später der Verweis auf die MainActivity-Instanz übergeben. Über ihn wird der Aufruf der openFileInput() Methode ausgeführt, wodurch das FileInputStream-Objekt erzeugt wird. Als Rückgabewert liefert die Methode ein List<Quote>-Objekt, das alle wiederhergestellten ListView-Einträge enthält, an den Aufrufer zurück.

In Zeile 6 wird die Text-Datei mit Hilfe der openFileInput() Methode ausgelesen. Dabei wird ein FileInputStream-Objekt erzeugt, das den Inhalt der Datei in Form eines Datenstroms in sich enthält. Der Aufruf der openFileInput() Methode erfolgt auf der Context-Instanz, daher ist der Methode auch der absolute Pfad zum privaten App-Verzeichnis bekannt.

Der erzeugte Datenstrom wird anschließend in Zeile 7 in ein InputStream-Objekt umgewandelt. Dies ist für unsere Anwendung sehr praktisch, da wir den InputStream mit Hilfe der in einer vorherigen Lektion bereits implementierten convertStreamToString() Methode in einen JSON-String umwandeln können. Dies geschieht in Zeile 9.

Zur Kontrolle lassen wir in Zeile 10 den erzeugten JSON-String per Log-Meldung auf der Konsole in Android Studio ausgeben. Dadurch können wir überprüfen, ob die ausgelesenen Daten auch in dem vom Webserver verwendeten JSON-Format vorliegen.

Im finally-Block wird schließlich in Zeile 17 der FileInputStream wieder geschlossen und abschließend der erzeugte JSON-String in eine Quote-Liste mit Hilfe der createQuotesFromJSONString() Methode umgewandelt. Das so erstellte List<Quote>-Objekt wird mit der return-Anweisung in Zeile 24 an den Aufrufer zurückgeliefert und die Methode dadurch verlassen.

Mit den oben beschriebenen Quellcodezeilen haben wir die beiden Hilfsmethoden saveQuoteListInFile() und restoreQuoteListFromFile() implementiert. Durch sie werden die ListView-Inhalte in einer Datei abgespeichert bzw. die gespeicherten Daten wieder aus der Datei ausgelesen. Alles was wir zum Speichern übergeben müssen, sind die ListView-Einträge in Form einer Quote-Liste und ein Verweis auf die MainActivity-Instanz. Zum Auslesen wird nur der Verweis auf die MainActivity-Instanz benötigt.

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

• Utility.java
• Projektstruktur

In der oberen Abbildung ist die überarbeitete Utility.java Klassendatei dargestellt. Dem Quellcode wurden vier Import-Anweisungen, die Konstante FILENAME_QUOTE_DATA und die beiden Hilfsmethoden saveQuoteListInFile() und restoreQuoteListFromFile() hinzugefügt. Beide hinzugefügten Methode sind aufgeklappt. Die fünf anderen Methoden wurden nicht verändert und sind daher zugeklappt geblieben.

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

1. A – Die benötigten Import-Anweisungen zum Sichtbarmachen der Klassen Context, FileInputStream, FileNotFoundException und FileOutputStream.
2. B – Die Konstanten FILENAME_QUOTE_DATA enthält den Namen der abzuspeichernden Datei.
3. C – Die saveQuoteListInFile() Methode zum Speichern des ListView-Inhalts in einer Datei.
4. D – Die restoreQuoteListFromFile() Methode zum Auslesen der gespeicherten Daten aus einer Datei.

Wir haben nun die beiden Hilfsmethoden saveQuoteListInFile() und restoreQuoteListFromFile() in der Utility-Klasse implementiert. Als Nächstes werden wir den Inhalt unseres ListViews in der MainActivity-Klasse auslesen und mit Hilfe der saveQuoteListInFile() Methode in einer Datei speichern. Zusätzlich werden wir auch das Wiederherstellen des ListView-Inhalts in der MainActivity-Klasse implementieren. Dafür werden wir die restoreQuoteListFromFile() Methode für das Auslesen der gespeicherten Daten nutzen.

3. Speichern und Auslesen einer Datei in der MainActivity-Klasse implementieren

Wir werden nun das persistente Speichern der ListView-Einträge in einer Datei und das anschließende Auslesen der dauerhaft gespeicherten Daten aus der Datei in der MainActivity-Klasse implementieren. Das Auslesen der Daten aus der Datei werden wir in der createQuoteList() Methode durchführen lassen. Diese wird innerhalb der onCreate() Callback-Methode beim Erstellen der Activity aufgerufen.

Das Speichern der Daten in die Zitatdaten.txt Datei werden wir in der onStop() Methode durchführen lassen. Somit werden die Inhalte des ListViews jedes mal persistent gespeichert, sobald die MainActivity in den Bildschirmhintergrund rückt und den Benutzer-Fokus verliert.

Wir öffnen nun die Klassendatei MainActivity.java im Editor von Android Studio mit einem Doppelklick auf ihren Dateinamen im Project Tool Window. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.zitate unseres Projekts.

Alle in die MainActivity.java Datei überarbeiteten bzw. hinzugefügten Codezeilen sind grau markiert worden:

In dem oben aufgeführten Quellcode der MainActivity.java Datei wurden die beiden Methoden createQuoteList() und onStop() bereits überarbeitet. Zudem wurde die Klasse File per Import-Anweisung sichtbar gemacht. Weitere Änderungen sind nicht an der MainActivity-Klasse vorzunehmen.

In Zeile 20 werden die File-Klassen mittels Import-Anweisungen innerhalb der MainActivity-Klasse sichtbar gemacht, so dass wir sie ohne den Namen ihres Packages verwenden können.

Die beiden überarbeiteten Methoden onStop() und createQuoteList() in den Zeilen 108 bis 118 und 181 bis 206 wurden ebenfalls markiert. In ihnen wird das Speichern und Auslesen der Datei veranlasst. Um Programmierfehler zu vermeiden, ist es sicherer, die beiden Methoden vollständig durch den oben markierten Quellcode zu ersetzten. Auch wenn sich nur einige Codezeilen verändert haben.

Die onStop() Methode

Wie bereits weiter oben erwähnt, wird in den Zeilen 108 bis 118 der MainActivity-Klasse die onStop() Methode definiert. Von ihr werden wir das Speichern des ListView-Inhalts in die Zitatdaten.txt Datei durchführen lassen. Die Datei wird dabei in das private Verzeichnis unserer Android App abgespeichert werden.

Wie sie sie dies ausführt, werden wir nun genauer betrachten. Die Methode ist daher zur Übersichtlichkeit an dieser Stelle nochmals aufgeführt:

protected void onStop() {
    super.onStop();
    Log.v(OUTER_TAG, "5. Stufe: onStop() betreten");

    if (mQuoteList.size() > 0) {
        Utility.saveQuoteListInFile(this, mQuoteList);
        Log.v(OUTER_TAG, "--> Zitatdaten in Datei gespeichert");
    } else {
        Log.v(OUTER_TAG, "--> Zitateliste ist leer. Es wurden keine Daten gespeichert.");
    }
}

Nur die Zeilen 5 bis 10 sind der onStop() Methode hinzugefügt worden.

Es sollen nur Daten in die Datei geschrieben werden, wenn die Datenquelle des ListViews nicht leer ist. Ob dies der Fall ist, wird mit der if-Anweisung in Zeile 5 geprüft. Der if-Zweig wird nur betreten, wenn die Quote-Liste, also die Datenquelle unserer App, mit Einträgen gefüllt ist.

Ist dies der Fall, wird in Zeile 6 die Hilfsmethode saveQuoteListInFile() der Utility-Klasse aufgerufen und dadurch die ListView-Einträge in der Datei gespeichert. Ihr werden beim Aufruf als Argumente der Verweis auf die MainActivity-Instanz und die Datenquelle mQuoteList des ListViews, die eine Liste von Quote-Objekten enthält, übergeben.

Anschließend wird in Zeile 7 eine kurze Log-Meldung an die Konsole ausgegeben. So können wir später zur Laufzeit kontrollieren, wann die Inhalte in die Datei auf den Gerätespeicher persistent geschrieben werden.

Falls keine Einträge in der Quote-Liste enthalten sind, wir der else-Zweig betreten und durch die Anweisung in Zeile 9 eine Log-Meldung ausgegeben, welche über die leere Zitateliste und das Abbrechen des Speichervorgangs informiert.

Die createQuoteList() Methode

Die createQuoteList() Methode wird in den Zeilen 181 bis 206 der MainActivity-Klasse definiert. Ihre Aufgabe ist das Erstellen der Quote-Liste, die als Datenquelle des ListViews dient. Dies wird von ihr je nach Vorhandensein der Zitatdaten.txt Datei auf zwei unterschiedliche Arten realisiert.

Befindet sich die genannte Datei in dem privaten App-Verzeichnis unserer App, werden die in der Datei enthaltenen Daten ausgelesen und mit ihnen die Datenquelle gefüllt. Falls die Datei noch nicht vorhanden ist, bspw. wenn unsere App das erste Mal nach der Installation gestartet wird, werden Beispieldaten für das Füllen der Datenquelle verwendet.

Wie dies im Detail erfolgt, werden wir nun genauer betrachten. Die Methode ist daher zur Übersichtlichkeit an dieser Stelle nochmals aufgeführt:

private void createQuoteList() {

    File quoteDataFile = getFileStreamPath(Utility.FILENAME_QUOTE_DATA);

    if (quoteDataFile.exists()) {
        mQuoteList = Utility.restoreQuoteListFromFile(this);
        Log.v(OUTER_TAG, "<-- Zitatdaten aus Datei geladen: " + quoteDataFile.getAbsolutePath());
    } else {
        String[] sampleQuotes = getResources().getStringArray(R.array.sample_quotes);

        Quote sampleQuote = new Quote(sampleQuotes[0], "Johann Wolfgang v. Goethe", "goethe");
        mQuoteList.add(sampleQuote);

        mQuoteList.add(new Quote(sampleQuotes[1], "Friedrich Schiller", "schiller"));
        mQuoteList.add(new Quote(sampleQuotes[2], "Johann Wolfgang v. Goethe", "goethe"));
        mQuoteList.add(new Quote(sampleQuotes[3], "Friedrich Schiller", "schiller"));
        mQuoteList.add(new Quote(sampleQuotes[4], "Johann Wolfgang v. Goethe", "goethe"));
        mQuoteList.add(new Quote(sampleQuotes[5], "Friedrich Schiller", "schiller"));
        mQuoteList.add(new Quote(sampleQuotes[6], "Johann Wolfgang v. Goethe", "goethe"));
        mQuoteList.add(new Quote(sampleQuotes[7], "Friedrich Schiller", "schiller"));
        mQuoteList.add(new Quote(sampleQuotes[8], "Johann Wolfgang v. Goethe", "goethe"));
        mQuoteList.add(new Quote(sampleQuotes[9], "Unbekannt", "unknown"));

        Log.v(OUTER_TAG, "*** Zitatdaten aus Beispieldaten erzeugt, da Datei noch nicht existiert");
    }
}

In Zeile 3 wird mit Hilfe der getFileStreamPath() Methode der absolute Pfad (inklusive Dateiname) zum privaten Verzeichnis unserer Android App angefordert, in das per openFileOutput() Methode Dateien gespeichert werden. Dieses Verzeichnis befindet sich in dem internen Speicher des Android Geräts und variiert je nach verwendetem Gerät.

In der if-Anweisung wird in Zeile 5 geprüft, ob sich die Zitatdaten.txt Datei in dem privaten Verzeichnis befindet. Ist dies der Fall, wird der if-Zweig betreten und eine Quote-Liste aus den in der Datei gespeicherten Daten mit Hilfe der Methode restoreQuoteListFromFile() erstellt und der Datenquelle mQuoteList des ListViews zugewiesen.

Zu Kontrolle wird in Zeile 7 eine kurze Log-Meldung an die Konsole ausgegeben, die über das erfolgte Wiederherstellen der Daten aus der Datei informiert und den absoluten Pfad zur Datei bekanntgibt.

Ist die Zitatdaten.txt Datei noch nicht vorhanden, wie es vor dem ersten Start unserer Android App unmittelbar nach der Installation der Fall ist, wird der else-Zweig betreten und die Datenquelle mit Beispieldaten gefüllt. Den darin enthaltenen Quellcode haben wir unverändert belassen. Es ist nur die letzte Anweisung in Zeile 24 hinzugefügt worden, die über das Erstellen von Beispiel-Zitatdaten per Log-Meldung informiert.

Mit den eben beschrieben Änderungen am Quellcode haben wir das persistente Speichern des ListView-Inhalts in einer Datei und das anschließende Wiederherstellen des Inhalts aus der Datei implementiert. Unsere Android App wird nun die ListView-Einträge in der Zitatdaten.txt Datei in Form eines JSON-Strings abspeichern, sobald die MainActivity in den Stopped State betritt. Wird die Activity später mit Hilfe der onCreate() Methode neue erzeugt, werden die gespeicherten Zitatdaten aus der Datei wieder ausgelesen und in ListView-Einträge umgewandelt.

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

• MainActivity.java
• Projektstruktur

In der oberen Abbildung ist die MainActivity.java Klassendatei dargestellt. Es wurden zwei Methoden überarbeitet und eine Import-Anweisung hinzugefügt. Es sind nur die beiden überarbeiteten Methoden aufgeklappt. Alle anderen Methoden sind unverändert geblieben und daher zugeklappt. Die hinzugefügten bzw. überarbeiteten Codezeilen sind mit Markierungen versehen worden.

Welche Bedeutung die jeweilige Zeile bzw. der jeweilige Code-Block besitzt, ist in der unteren Liste angegeben:

1. E – Die benötigten Import-Anweisung zum Sichtbarmachen der Klasse File.
2. F – Die onStop() Methode von der das Speichern des ListView-Inhalts in einer Datei veranlasst wird.
3. G – Die createQuoteList() Methode von der die Datenquelle, eine Quote-Liste, aus den in der Datei gespeicherten Daten erzeugt wird. Ist die Datei noch nicht vorhanden, wird die Datenquelle mit Beispieldaten gefüllt.

Wir haben nun die Methoden onStop() und createQuoteList() so überarbeitet, dass durch sie der Inhalt unseres ListViews in einer Datei gespeichert und wieder aus der Datei ausgelesen wird. Der Inhalt wird persistent gespeichert, sobald die MainActivity den Stopped State betritt. Wird die Activity später wieder neu erzeugt, werden alle Einträge des ListViews aus den in der Datei gespeicherten Daten wiederhergestellt.

Unsere App erzeugt dabei zwei Log-Meldungen, die über das Speichern und Auslesen der Daten informieren. Diese möchten wir als Nächstes im Logcat Tool Window von Android Studio auswerten, wenn wir unsere App auf einem Android Virtual Device im Emulator ausführen lassen, und dabei die korrekt Funktion unserer Implementierung überprüfen.

4. Ausführen und Testen unserer Android App

Wir werden nun unserer Android App auf einem Android Virtual Device im Emulator ausführen lassen. Dabei möchten wir die Log-Meldungen unserer Anwendung in Echtzeit verfolgen und dadurch analysieren, wann sie den ListView-Inhalt in der Datei speichert bzw. aus der Datei wiederherstellt.

In der rechten Abbildung ist der Android Activity Lifecycle ab Android 9.0 dargestellt. Das Diagramm gibt Aufschluss darüber, wann sich die MainActivity in welchen Zustand befindet und über welche Methode sie diesen Zustand erreicht hat.

Wie bereits weiter oben beschrieben, wird der ListView-Inhalt in einer Datei gespeichert, sobald die Activity den Stopped State betritt. Das persistente Speichern erfolgt daher in der onStop() Callback-Methode. Unsere App informiert uns darüber mit einer kurzen Log-Meldung kurz nachdem die onStop() Methode betreten wurde.

Die Activity verweilt anschließend in den Stopped-Zustand. Ihre Instanz wird während dieser Zeit vollständig intakt im Speicher des Android Systems gehalten. Kehrt der Benutzer dann wieder zur Activity zurück, muss sie nicht erneut erzeugt werden. Der ListView-Inhalt ging nicht verloren und muss daher auch nicht wiederhergestellt werden.

Wird die Activity vom Android System zerstört, geht ihre Instanz und somit auch der ListView-Inhalt verloren. Dabei spielt es keine Rolle, ob der Benutzer die Activity endgültig schließt oder sie vom Android System aufgrund von Systembeschränkungen zerstört werden muss.

Da alle Informationen über die zerstörte Activity verloren gegangen sind, muss sie vom Android System neu erzeugt werden, falls der Benutzer erneut zu ihr navigiert. Dabei wird die onCreate() Callback-Methode vom Android System aufgerufen, in der die createQuoteList() Methode aufgerufen wird, die für das Erzeugen der Datenquelle, einer Quote-Liste, verantwortlich ist.

In der createQuoteList() Methode lassen wir die Einträge des ListViews aus der gespeicherten Datei wiederherstellen. Auch darüber informiert uns unsere App mit einer kurzen Log-Meldung, sobald die createQuoteList() Methode von der onCreate() Methode aufgerufen wurde. In dieser Log-Meldung wird auch der absolute Pfad zur ausgelesenen Datei bekanntgegeben. Sollte die Datei noch nicht erstellt worden sein, wie es direkt nach der Installation unserer App der Fall ist, werden die ListView-Einträge aus Beispieldaten generiert. Auch darüber informiert uns unserer App mit einer kurzen Log-Meldung.

Wir werden nun den eben beschriebenen Ablauf mit Hilfe der Log-Meldungen im Logcat Tool Window von Android Studio genauer untersuchen. Dazu führen wir nun unsere App auf dem Android Virtual Device im Emulator aus.

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

Sobald unsere App auf dem AVD ausgeführt wird, werden wir das Speichern des ListView-Inhalts in einer Datei und anschließende Wiederherstellen des Inhalts aus der Datei überprüfen. Und zwar, indem wir diesen Vorgang mit Hilfe von Log-Meldungen im Logcat Tool Window von Android Studio verfolgen. Unsere App gibt jeweils eine kurze Log-Meldung an die Konsole aus, sobald sie Daten in die Datei schreibt bzw. sobald sie diese wieder aus der Datei ausliest.

Die Log-Meldungen können wir im Logcat Tool Window folgendermaßen betrachten:

1. Wir öffnen das Logcat Tool Window mit einem Klick auf den Logcat-Tab am unteren Bildschirmrand.
2. In der Drop-Down Liste stellen wir die Prioritätsstufe auf Verbose ein.
3. In das anschließende Suchfeld geben wir MainActivity als Suchbegriff ein.
4. Für die hintere Drop-Down Liste stellen wir sicher, dass der Eintrag Show only selected application ausgewählt ist.

In der oberen Abbildung ist die Logcat-Ausgabe unserer Android App zu sehen. Unsere Anwendung wurde gerade gestartet, ist im Bildschirmvordergrund und besitzt den Benutzer-Fokus. Sie befindet sich momentan im Resumed State, welchen sie über die Callback-Methoden onCreate(), onStart() und onResume() erreicht hat.

Da die Datei Zitatdaten.txt bisher noch nicht in dem privaten Verzeichnis unserer Android App erstellt wurde und somit auch noch nicht existiert, müssen die ListView-Einträge aus Beispieldaten generiert werden.

Als nächsten Schritt möchten wir unsere Android App beenden und dadurch die ListView-Einträge in die Datei speichern lassen. Mit einem Klick auf den Back-Button verlassen wir unsere App, worauf sich folgende Log-Meldung ergibt:

Die Activity wird, durch das Verlassen der App mittels Back-Button, nun vom Android System vollständig und endgültig zerstört. Dabei wird zuerst die onPause() Methode aufgerufen, danach die onStop() Methode und schließlich die onDestroy() Methode, in welcher die Activity vollständig zerstört wird.

Bei diesem Vorgang wurde innerhalb der onStop() Methode der ListView-Inhalt in einer Datei auf dem Gerätespeicher persistent gespeichert. Der Inhalt kann somit wieder ausgelesen werden, wenn der Benutzer erneut unsere App startet und sie dadurch vom Android System neu erzeugt wird.

Hinweis: Die MainActivity ist endgültig zerstört worden. Es wurde vom Android System nicht versucht den Zustand der Activity zu speichern, da Android davon ausgeht, dass der Benutzer mit der Activity fertig ist. Aus diesem Grund wurde die onSaveInstanceState() Methode auch nicht aufgerufen und auch kein Bundle-Objekt erzeugt. Der ListView-Inhalt kann nur noch aus der persistent gespeicherten Datei wiederhergestellt werden.

Als nächsten Schritt möchten wir unsere Android App erneut öffnen. Dazu navigieren wir in das Alle Apps-Menü und klicken auf das Symbol der Zitate-App. Daraufhin wird unsere App vom Android System neu erstellt.

Als Ergebnis erhalten wir folgende Log-Meldungen in Android Studio angezeigt:

Die MainActivity wird nun vom Android System durch Aufruf der onCreate() Methode wieder neu erzeugt. Innerhalb der onCreate() Methode wird die createQuoteList() Methode aufgerufen wird, die für das Erzeugen der Datenquelle aus der Datei bzw. aus Beispieldaten zuständig ist.

Da nun die Datei Zitatdaten.txt im privaten App-Verzeichnis vorhanden ist, kann die createQuoteList() Methode die ListView-Einträge aus der Datei wiederherstellen. Eine kurzen Log-Meldung informiert darüber. Zudem wird auch der absolute Pfad zur Datei in der Log-Meldung mitgeteilt.

Nach der onCreate() Methode werden die onStart() und onResume() Methoden vom Android System aufgerufen. Die Activity betritt am Ende dieser Kette ihren Resumed State. Sie besitzt nun wieder den Benutzer-Fokus und befindet sich vollständig im Bildschirmvordergrund.

Hinweis: Da beim vorherigen Zerstören der Activity kein Bundle-Objekt erzeugt wurde, ging der Instance State der Activity verloren. Dadurch können nicht alle ihre Eigenschaften, bspw. die Scroll-Position des ListViews, wiederhergestellt werden. Dies ist auch der Grund, warum die onRestoreInstanceState() Methode vom Android System nicht aufgerufen wurde.

Als letzten Schritt möchten wir unsere Android App erneut beenden. Mit einem Klick auf den Back-Button verlassen wir unsere App, worauf sich folgende Log-Meldung ergibt:

Die Activity wird, durch das Verlassen der App mittels Back-Button, nun vom Android System vollständig und endgültig zerstört. Dabei wird zuerst die onPause() Methode aufgerufen, danach die onStop() Methode und schließlich die onDestroy() Methode, in welcher die Activity vollständig zerstört wird.

Bei diesem Vorgang wird erneut innerhalb der onStop() Methode der ListView-Inhalt in der Datei Zitatdaten.txt auf dem Gerätespeicher gespeichert. Der Inhalt kann später von unserer App wiederhergestellt werden, da er dauerhaft in der Datei im privaten Verzeichnis unserer Android App gespeichert wurde.

Zusammenfassung

In dieser Lektion haben wir mit unserer App auf den internen Speicher des Android Geräts zugegriffen. Dabei haben wir von der onStop() Methode den Inhalt unseres ListViews in einer Datei abspeichern und von der onCreate() Methode anschließend wieder aus der Datei auslesen lassen.

Auf diese Weise blieben die ListView-Einträge über die Lebenszeit unserer Android App (und ihrer Activity) hinaus erhalten. Da die Daten persistent in der Datei gespeichert worden sind, kann der ListView-Inhalt beim Neuerstellen der MainActivity wieder vollständig hergestellt werden.

Im theoretischen Teil dieser Lektion haben wir betrachtet, auf welche Arten Anwendungs- und Nutzerdaten in Android gespeichert werden können. Und dabei erfahren, wie Daten in einer Datei persistent im Gerätespeicher abgelegt und später aus der Datei wieder ausgelesen werden können.

Anschließend haben wir im praktischen Teil das Speichern und Laden des ListView-Inhalts implementiert. Dafür wurden zunächst die beiden Hilfsmethoden saveQuoteListInFile() und restoreQuoteListFromFile() in der Utility-Klasse definiert. Sie sind für das persistente Speichern des ListView-Inhalts in einer Datei und für das Auslesen der gespeicherten Daten aus einer Datei zuständig.

Auf die beiden Hilfsmethoden haben wir dann von der MainActivity-Klasse aus zugegriffen. Von der onStop() Methode der MainActivity haben wir den ListView-Inhalt auslesen und mit Hilfe der saveQuoteListInFile() Hilfsmethode in einer Datei auf dem internen Speicher des Android Geräts abspeichern lassen. Von der createQuoteList() Methode, die von der onCreate() Methode aufgerufen wird, haben wir die gespeicherten Daten aus der Datei wieder auslesen und dem ListView als Datenquelle zuweisen lassen.

Abschließend haben wir unsere Android App im Emulator auf einem Android Virtual Device ausgeführt und überprüft, ob der Inhalt des ListViews persistent in einer Datei gespeichert und korrekt aus der Datei wiederhergestellt wird.

In der nächsten Lektion werden wir das Intent System von Android kennenlernen. Intents sind abstrakte Beschreibungen von auszuführenden Vorhaben und werden am häufigsten in Android für das Starten von Activities eingesetzt. Dafür werden auch wir sie in den nächsten Lektionen verwenden, wenn wir eine weitere Activity unserem Android Projekt hinzufügen und von einem Intent starten lassen.

Weiterführende Literatur

• Developer.android.com: App Data and Files
• Developer.android.com: Data and File Storage Overview
• Developer.android.com: Save Files on Device Storage
• Developer.android.com: Context Reference
• Developer.android.com: File Reference

---

---

---