Introduction to Android Application Development, Fourth Edition (2014)

---

Exploring with the Android Application Directories

Android application data is stored on the Android file system in the following top-level directory:

/data/data/<package name>/

Several default subdirectories are created for storing databases, preferences, and files as necessary. The actual location of these directories varies by device. You can also create other custom directories as needed. All file operations begin by interacting with the application Context object.Table 12.1 lists some important methods available for application file management. You can use all the standard java.io package utilities to work with FileStream objects and such.

Table 12.1 Important android.content.Context File Management Methods

Creating and Writing to Files in the Default Application Directory

Android applications that require only the occasional file to be created should rely upon the helpful Context class method called openFileOutput(). Use this method to create files in the default location under the application data directory:

/data/data/<package name>/files/

For example, the following code snippet creates and opens a file called Filename.txt. We write a single line of text to the file and then close the file:

import java.io.FileOutputStream;
...
FileOutputStream fos;
String strFileContents = "Some text to write to the file.";
fos = openFileOutput("Filename.txt", MODE_PRIVATE);
fos.write(strFileContents.getBytes());
fos.close();

We can append data to the file by opening it with the mode set to MODE_APPEND:

import java.io.FileOutputStream;
...
FileOutputStream fos;
String strFileContents = "More text to write to the file.";
fos = openFileOutput("Filename.txt", MODE_APPEND);
fos.write(strFileContents.getBytes());
fos.close();

The file we created has the following path on the Android file system:

/data/data/<package name>/files/Filename.txt

Figure 12.1 shows a screen capture of an Activity that is configured to collect text input from a user, and then writes the information to a text file when Send is clicked.

Figure 12.1 A screen capture of an Activity that is capable of writing to a text file.

Reading from Files in the Default Application Directory

Again we have a shortcut for reading files stored in the default /files subdirectory. The following code snippet opens a file called Filename.txt for read operations:

import java.io.FileInputStream;
...
String strFileName = "Filename.txt";
FileInputStream fis = openFileInput(strFileName);

Figure 12.2 shows a screen capture of an Activity that is configured to read the information from a text file upon launching of the Activity.

Figure 12.2 A screen capture of an Activity reading from a text file and displaying the contents.

Reading Raw Files Byte by Byte

You handle file-reading and file-writing operations using standard Java methods. The java.io.InputStreamReader and java.io.BufferedReader are used for reading bytes and characters from different types of primitive file types. Here’s a simple example of how to read a text file, line by line, and store it in a StringBuffer:

FileInputStream fis = openFileInput(filename);
StringBuffer sBuffer = new StringBuffer();
BufferedReader dataIO = new BufferedReader (new InputStreamReader(fis));
String strLine = null;

while ((strLine = dataIO.readLine()) != null) {
sBuffer.append(strLine + "\n");
}

dataIO.close();
fis.close();

Reading XML Files

The Android SDK includes several utilities for working with XML files, including SAX, an XML Pull Parser, and limited DOM, Level 2 Core support. Table 12.2 lists the packages helpful for XML parsing on the Android platform.

Table 12.2 Important XML Utilities

Your XML parsing implementation will depend on which parser you choose to use. Back in Chapter 6, “Managing Application Resources,” we discussed including raw XML resource files in your application package. Here is a simple example of how to load an XML resource file and parse it using an XmlPullParser.

The XML resource file contents, as defined in the /res/xml/my_pets.xml file, are as follows:

<?xml version="1.0" encoding="UTF-8"?>
<!-- Our pet list -->
<pets>
<pet type="Bunny" name="Bit"/>
<pet type="Bunny" name="Nibble"/>
<pet type="Bunny" name="Stack"/>
<pet type="Bunny" name="Queue"/>
<pet type="Bunny" name="Heap"/>
<pet type="Bunny" name="Null"/>
<pet type="Fish" name="Nigiri"/>
<pet type="Fish" name="Sashimi II"/>
<pet type="Lovebird" name="Kiwi"/>
</pets>

The following code illustrates how to parse the preceding XML using a special pull parser designed for XML resource files:

XmlResourceParser myPets = getResources().getXml(R.xml.my_pets);
int eventType = -1;
while (eventType != XmlResourceParser.END_DOCUMENT) {
if(eventType == XmlResourceParser.START_DOCUMENT) {
Log.d(DEBUG_TAG, "Document Start");
} else if(eventType == XmlResourceParser.START_TAG) {
String strName = myPets.getName();
if(strName.equals("pet")) {
Log.d(DEBUG_TAG, "Found a PET");
Log.d(DEBUG_TAG,
"Name: "+myPets.getAttributeValue(null, "name"));
Log.d(DEBUG_TAG,
"Species: "+myPets.
getAttributeValue(null, "type"));
}
}
eventType = myPets.next();
}
Log.d(DEBUG_TAG, "Document End");