Accessing Preferences Using an Activity

In the following Try It Out, you see how to use the SharedPreferences object to store application data. You also find out how the stored application data can be modified directly by the user through a special type of activity provided by the Android OS.

Programmatically Retrieving and Modifying the Preferences Values

In the previous section, you saw how the PreferenceActivity class both enables developers to easily create preferences and enables users to modify them during runtime. To make use of these preferences in your application, you use the SharedPreferences class. The following Try It Out shows you how.

Saving to Internal Storage

The first way to save files in your Android application is to write to the device's internal storage. The following Try It Out demonstrates how to save a string entered by the user to the device's internal storage.

Saving to External Storage (SD Card)

The previous section showed how you can save your files to the internal storage of your Android device. Sometimes, it would be useful to save them to external storage (such as an SD card) because of its larger capacity, as well as the capability to share the files easily with other users (by removing the SD card and passing it to somebody else). You can use the following steps to save files to external storage:

1. Using the project created in the previous section as the example (saving text entered by the user to the SD card), modify the onClick() method of the Save button as shown in bold here:

   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStreamReader;
   import java.io.OutputStreamWriter;
   import android.app.Activity;
   import android.os.Bundle;
   import android.os.Environment;
   import android.view.View;
   import android.widget.EditText;
   import android.widget.Toast;
       public void onClickSave(View view) {
           String str = textBox.getText().toString();
           try
           {
               //---SD Card Storage---
               File sdCard = Environment.getExternalStorageDirectory();
               File directory = new File (sdCard.getAbsolutePath() +
                   "/MyFiles");
               directory.mkdirs();
               File file = new File(directory, "textfile.txt");
               FileOutputStream fOut = new FileOutputStream(file);
               /*
               FileOutputStream fOut =
                       openFileOutput("textfile.txt",
                               MODE_WORLD_READABLE);
               */
               OutputStreamWriter osw = new
                       OutputStreamWriter(fOut);
               //---write the string to the file---
               osw.write(str);
               osw.flush();
               osw.close();
               //---display file saved message---
               Toast.makeText(getBaseContext(),
                       "File saved successfully!",
                       Toast.LENGTH_SHORT).show();
               //---clears the EditText---
               textBox.setText("");
           }
           catch (IOException ioe)
           {
               ioe.printStackTrace();
           }
       }

2. The preceding code uses the getExternalStorageDirectory() method to return the full path to the external storage. Typically, it should return the “/sdcard” path for a real device, and “/mnt/sdcard” for an Android emulator. However, you should never try to hardcode the path to the SD card, as manufacturers may choose to assign a different path name to the SD card. Be sure to use the getExternalStorageDirectory() method to return the full path to the SD card.
3. You then create a directory called MyFiles in the SD card.
4. Finally, you save the file into this directory.
5. To load the file from the external storage, modify the onClickLoad() method for the Load button:

       public void onClickLoad(View view) {
           try
           {
               //---SD Storage---
               File sdCard = Environment.getExternalStorageDirectory();
               File directory = new File (sdCard.getAbsolutePath() +
                   "/MyFiles");
               File file = new File(directory, "textfile.txt");
               FileInputStream fIn = new FileInputStream(file);
               InputStreamReader isr = new InputStreamReader(fIn);
               /*
               FileInputStream fIn =
                       openFileInput("textfile.txt");
               InputStreamReader isr = new
                       InputStreamReader(fIn);
               */
               char[] inputBuffer = new char[READ_BLOCK_SIZE];
               String s = "";
               int charRead;
               while ((charRead = isr.read(inputBuffer))>0)
               {
                   //---convert the chars to a String---
                   String readString =
                           String.copyValueOf(inputBuffer, 0,
                                   charRead);
                   s += readString;
                   inputBuffer = new char[READ_BLOCK_SIZE];
               }
               //---set the EditText to the text that has been
               // read---
               textBox.setText(s);
               Toast.makeText(getBaseContext(),
                       "File loaded successfully!",
                       Toast.LENGTH_SHORT).show();
           }
           catch (IOException ioe) {
               ioe.printStackTrace();
           }
       }

6. Note that in order to write to the external storage, you need to add the WRITE_EXTERNAL_STORAGE permission in your AndroidManifest.xml file:

   <?xml version="1.0" encoding="utf-8"?>
   <manifest xmlns:android="http://schemas.android.com/apk/res/android"
       package="com.jfdimarzio.Files"
       android:versionCode="1"
       android:versionName="1.0" >
       <uses-sdk android:minSdkVersion="14"/>
       <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
       <application
           android:icon="@drawable/ic_launcher"
           android:label="@string/app_name" >
           <activity
               android:label="@string/app_name"
               android:name=".FilesActivity" >
               <intent-filter >
                   <action android:name="android.intent.action.MAIN"/>
                   <category android:name="android.intent.category.LAUNCHER"/>
               </intent-filter>
           </activity>
       </application>
   </manifest>

Choosing the Best Storage Option

The previous sections described three main ways to save data in your Android applications: the SharedPreferences object, internal storage, and external storage. Which one should you use in your applications? Here are some guidelines:

• If you have data that can be represented using name/value pairs, then use the SharedPreferences object. For example, if you want to store user preference data such as username, background color, date of birth, or last login date, then the SharedPreferences object is the ideal way to store this data. Moreover, you don't really have to do much to store data this way. Simply use the SharedPreferences object to store and retrieve it.
• If you need to store ad-hoc data then using the internal storage is a good option. For ­example, your application (such as an RSS reader) might need to download images from the web for display. In this scenario, saving the images to internal storage is a good solution. You might also need to persist data created by the user, such as when you have an application that enables users to take notes and save them for later use. In both of these scenarios, using the internal storage is a good choice.
• There are times when you need to share your application data with other users. For example, you might create an Android application that logs the coordinates of the locations that a user has been to, and subsequently, you want to share all this data with other users. In this scenario, you can store your files on the SD card of the device so that users can easily transfer the data to other devices (and computers) for use later.

Creating the DBAdapter Helper Class

A good practice for dealing with databases is to create a helper class to encapsulate all the complexities of accessing the data so that it is transparent to the calling code. For this section, you create a helper class called DBAdapter, which creates, opens, closes, and uses a SQLite database.

In this example, you are going to create a database named MyDB containing one table named contacts. This table has three columns: _id, name, and email.

Using the Database Programmatically

With the DBAdapter helper class created, you are now ready to use the database. In the following sections, you will learn how to perform the regular CRUD (create, read, update and delete) operations commonly associated with databases.

public class DBAdapter {
    static final String KEY_ROWID = "_id";
    static final String KEY_NAME = "name";
    static final String KEY_EMAIL = "email";
    static final String TAG = "DBAdapter";
    static final String DATABASE_NAME = "MyDB";
    static final String DATABASE_TABLE = "contacts";
    static final int DATABASE_VERSION = 2;

DBAdapter(8705): Upgrading database from version 1 to 2, which
will destroy all old data