Storage

Data
Storage Methods
in Android
Data Storage
•  Applica4ons o5en need to use some type of data storage for
persistent data.
•  The Android framework offers different data storage op4ons:
–  Shared preferences:
•  Useful for storing primi4ve data in key-‐value pairs
•  Lightweight usage, such as saving applica4on seEngs, UI state
–  Flat file based storage:
•  Storing private data in device memory
•  Storing public data on external storage, e.g., SD card
•  Uses standard Java file storage access methods: InputFileStream and
OutputFileStream
–  SQLite database:
•  Provides a means of storing structured data in a private database
•  You can also store your data on a network server and access it
using the network
COMP 355 (Muppala) Data Storage 2

Shared Preferences

Shared Preferences
•  This class provides a general framework that allows saving
and retrieving of persistent key-‐value pairs of primi4ve data
•  Typical usage of SharedPreferences is for saving applica4on
seEngs such as user seEngs, theme, login informa4on such
as username and password, auto login flag, remember-‐user
flag etc.
•  The shared preferences informa4on is stored in an XML file
on the device
–  Typically in /data/data/<Your applica4on’s package name>/
shared_prefs
•  SharedPreferences can be associated with the en4re
applica4on, or to a specific ac4vity

Shared Preferences
•  Use the getSharedPreferences() method to get access to the shared
preferences
•  Example:
SharedPreferences prefs = this.getSharedPreferences(“myPrefs”,
MODE_PRIVATE);
•  If the preferences XML file exists, it is opened, otherwise it is
created
•  To control access permissions to the file:
–  MODE_PRIVATE: private only to the applica4on
–  MODE_WORLD_READABLE: all applica4ons can read the XML file
–  MODE_WORLD_WRITEABLE: all applica4ons can write the XML file
•  If you are using SharedPreferences for a specific ac4vity, then use
getPreferences() method
–  No need to specify the name of the preferences file

Shared Preferences
•  To add shared preferences, first an Editor object is needed:
Editor prefsEditor = prefs.edit();
•  Then, use the put() method to add the key-‐value pairs:
prefsEditor.putString(“username”, “user1”);
prefsEditor.putString(“password”, “pass1234”);
prefsEditor.putInt(“4mes-‐login”,1);
prefsEditor.commit();
•  To retrieve shared preferences data:
String username = prefsEditor.getString(“username”,””);
String password = prefsEditor.getString(“password”,””);


User Preferences and PreferenceAc4vity
•  SeEng user preferences for an applica4on is supported in

Android through the PreferenceAc4vity class
–  Provides an ac4vity framework to create user preferences
–  Preferences are automa4cally persisted using shared preferences
•  To add preferences to your applica4on:
–  Create a preferences.xml file in the /res/xml directory:
–  Create a new ac4vity extending PreferenceAc4vity and reading in the
default preferences from the xml file above
–  Add the ac4vity to your AndroidManifest.xml file
–  Invoke your preference ac4vity from another ac4vity

Flat File Storage

Flat File Storage
•  Files are used to store large amount of data
•  Generally not recommended to use files
•  Use I/O interfaces provided by java.io.* libraries to read/write
files.
•  Only local files can be accessed.
–  Advantage: can store large amount of data.
–  Disadvantage: Upda4ng files or changing their format may lead to
massive coding work.

File Opera4on (Read)
•  Read file
–  Use Context.openFileInput(String name) to open a private input file
stream related to a program
–  Throw FileNotFoundExcep4on when the file does not exist.

FileInputStream in = this.openFileInput(“rt.txt");//Open file “rt.txt"
……
in.close();//Close input stream

File Opera4on (Write)
•  Write File
–  Use Context.openFileOutput(String name,int mode) to open a private
output file stream related to a program
–  The file will be created if it does not exist.
–  Output stream can be opened in append mode, which means new
data will be appended to end of the file.
String mystring = “Hello, World!”;

FileOutputStream ouoile = this.openFileOutput(“myfile.txt",MODE_APPEND);
//Open and write in “myfile.txt”, using append mode.
Ouoile.write(mystring.getBytes());
ouoile.close();//Close output stream Also possible to use:
MODE_PRIVATE,
MODE_WORLD_READABLE
MODE_WORLD_WRITEABLE
Read Sta4c Files
•  Sta4c files that are included in the applica4on are created in
the /res/raw directory
•  Read-‐only sta4c files
•  Use Resources.openRawResource(R.raw.mydatafile) to open
sta4c files.
InputStream myFile = getResources().openRawResource(R.raw.myfilename);
… //Get context resource
myFile.close(); //Close input stream

External Storage
•  Every Android-‐compa4ble device supports a shared "external
storage" that you can use to save files
–  Removable storage media (such as an SD card)
–  Internal (non-‐removable) storage
•  Files saved to the external storage are world-‐readable and
can be modified by the user when they enable USB mass
storage to transfer files on a computer

External Storage
•  Must check whether external storage is available first by calling
getExternalStorageState()
–  Also check whether it allows read/write before reading/wri4ng on it
•  Example:
if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
File sdCardDir = Environment.getExternalFilesDir(null);//Get SD Card directory
File outFile = new File(sdCardDir, “example.txt”);
FileOutputStream outStream = new FileOutputStream(outFile);
outStream.write(”Hello, world!".getBytes());
outStream.close();
}
•  These files are private to the applica4on and will be removed when
the applica4on is uninstalled
•  getExternalFilesDir() takes a parameter such as DIRECTORY_MUSIC,
DIRECTORY_RINGTONES etc., to open specific type of
subdirectories

External Storage
•  For public shared directories, use
getExternalStoragePublicDirectory()
•  For cache files, use getExternalCacheDir()
•  All these are applicable for API level 8 or above
•  For API level 7 or below, use the method:
–  getExternalStorageDirectory()
–  private files stored in /Android/data/<package_name>/files/
–  Cache files stored in /Android/data/<package_name>/cache/

SQLite Databases

SQLite Database
•  Android applica4ons can have applica4on databases powered by
SQLite
–  Lightweight and file-‐based, ideal for mobile devices
–  Databases are private for the applica4on that creates them
–  Databases should not be used to store files
•  SQLite is a light weight database
–  Atomic
–  Stable
–  Independent
–  Enduring
–  Only several kilobytes
–  Only partly support some SQL commands such as ALTER, TABLE.
•  SQLite is included as part of Android’s so5ware stack
•  More info about SQLite at hup://www.sqlite.org

SQLite Databases
•  Steps for using SQLite databases:
1.  Create a database
2.  Open the database
3.  Create a table
4.  Create and insert interface for datasets
5.  Create a query interface for datasets
6.  Close the database
•  Good prac4ce to create a Database Adapter class to simplify
your database interac4ons
•  We will use the SQLite database defined in the notebook
tutorial as an example

SQLite Example: Notebook Tutorial
public class NotesDbAdapter {

public sta3c final String KEY_TITLE = "+tle";
public sta3c final String KEY_BODY = "body";
public sta3c final String KEY_ROWID = "_id";

private sta3c final String TAG = "NotesDbAdapter";
private DatabaseHelper mDbHelper;
private SQLiteDatabase mDb;

/**
* Database crea4on sql statement
*/
private sta3c final String DATABASE_CREATE =
"create table notes (_id integer primary key autoincrement, "
+ "4tle text not null, body text not null);";

private sta3c final String DATABASE_NAME = "data";
private sta3c final String DATABASE_TABLE = "notes";
private sta3c final int DATABASE_VERSION = 2;

private final Context mCtx;

SQLiteOpenHelper Class
•  Abstract class for implemen4ng a best prac4ce pauern for crea4ng,
opening and upgrading databases
•  To create a SQLite database, the recommended approach is to create a
subclass of SQLiteOpenHelper class
•  Then override its onCreate() method
–  Then execute a SQLite command to create tables in the database
•  Use the onUpgrade() method to handle upgrade of the database
–  A simple way would be to drop an exis4ng table and replace with a new defeni4on
–  Beuer to migrate exis4ng data into a new table
•  Then use an instance of the helper class to manage opening or upgrading
the database
–  If the database doesn’t exist, the helper will create one by calling its onCreate()
handler
–  If the database version has changed, it will upgrade by calling the onUpgrade()
handler

private sta3c class DatabaseHelper extends SQLiteOpenHelper {

DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}

@Override
public void onCreate(SQLiteDatabase db) {

db.execSQL(DATABASE_CREATE);
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
+ newVersion + ", which will destroy all old data");
db.execSQL("DROP TABLE IF EXISTS notes");
onCreate(db);
}
}

public NotesDbAdapter(Context ctx) {
this.mCtx = ctx;
}

public NotesDbAdapter open() throws SQLExcep3on {
mDbHelper = new DatabaseHelper(mCtx);
mDb = mDbHelper.getWritableDatabase();
return this;
}

public void close() {
mDbHelper.close();
}

SQLite Databases
•  ContentValues() objects used to hold rows to be inserted into the database
•  Example:
public long createNote(String 3tle, String body) {
ContentValues ini4alValues = new ContentValues();
ini4alValues.put(KEY_TITLE, Mtle);
ini4alValues.put(KEY_BODY, body);

return mDb.insert(DATABASE_TABLE, null, ini+alValues);
}

public boolean deleteNote(long rowId) {

return mDb.delete(DATABASE_TABLE, KEY_ROWID + "=" + rowId, null) > 0;
}
public boolean updateNote(long rowId, String 3tle, String body) {
ContentValues args = new ContentValues();
args.put(KEY_TITLE, Mtle);
args.put(KEY_BODY, body);

return mDb.update(DATABASE_TABLE, args, KEY_ROWID + "=" + rowId, null) > 0;
}

SQLite Databases
•  Database queries are returned as Cursor objects
–  Pointers to the resul4ng sets within the underlying data
•  Cursor class provides several methods:
–  moveToFirst, moveToNext, moveToPrevious, moveToPosi4on used to
move to a row
–  getCount to get the number of rows in the cursor
–  getPosi4on to get the current row posi4on
–  getColumnName, getColumnNames, getColumnIndexorThrow to get
info on columns
–  startManagingCursor and stopManagingCursor methods used to
integrate cursor life4me into the ac4vity’s life4me

public Cursor fetchAllNotes() {

return mDb.query(DATABASE_TABLE, new String[] {KEY_ROWID, KEY_TITLE,
KEY_BODY}, null, null, null, null, null);
}
public Cursor fetchNote(long rowId) throws SQLExcep3on {

Cursor mCursor =

mDb.query(true, DATABASE_TABLE, new String[] {KEY_ROWID,
KEY_TITLE, KEY_BODY}, KEY_ROWID + "=" + rowId, null,
null, null, null, null);
if (mCursor != null) {
mCursor.moveToFirst();
}
return mCursor;

}

•  Within the main ac4vity, cursors returned by the Dbadapter are used as
follows:
private void fillData() {
Cursor notesCursor = mDbHelper.fetchAllNotes();
startManagingCursor(notesCursor);

// Create an array to specify the fields we want to display in the list (only TITLE)
String[] from = new String[]{NotesDbAdapter.KEY_TITLE};

// and an array of the fields we want to bind those fields to (in this case just text1)
int[] to = new int[]{R.id.text1};

// Now create a simple cursor adapter and set it to display
SimpleCursorAdapter notes =
new SimpleCursorAdapter(this, R.layout.notes_row, notesCursor, from, to);
setListAdapter(notes);
}

Content Providers

Content Providers
•  Store and retrieve data and make it available to all applica4ons
–  Only way to share data across applica4ons
•  Standard content providers part of Android:
–  Common data types (audio, video, images, personal contact informa4on)
•  Applica4ons can create their own content providers to make their
data public
–  Alterna4vely add the data to an exis4ng provider
•  Implement a common interface for querying the provider, adding,
altering and dele4ng data
•  Actual storage of data is up to the designer
•  Provides a clean separa4on between the applica4on layer and data
layer

Accessing Content
•  Applica4ons access the content through a ContentResolver
instance
–  ContentResolver allows querying, inser4ng, dele4ng and upda4ng
data from the content provider
ContentResolver cr = getContentResolver();

cr.query(People.CONTENT_URI, null, null, null, null); //querying contacts

ContentValues newvalues = new ContentValues();
cr.insert(People.CONTENT_URI, newvalues);

cr.delete(People.CONTENT_URI, null, null); //delete all contacts

Content Providers
•  Content providers expose their data as a simple table on a
database model
–  Each row is a record and each column is data of a par4cular type and
meaning
•  Queries return cursor objects
•  Each content provider exposes a public URI that uniquely
iden4fies its data set
–  Separate URI for each data set under the control of the provider
–  URIs start with content://…
–  Typical format:
Content://<package name>.provider.<custom provider name>/<DataPath>

Content Providers: Query
•  You need three pieces of informa4on to query a content provider:
–  The URI that iden4fies the provider
–  The names of the data fields you want to receive
–  The data types for those fields
•  If you're querying a par4cular record, you also need the ID for that record
•  Example:
import android.provider.Contacts.People;
import android.content.ContentUris;
import android.net.Uri;
import android.database.Cursor;

// Use the ContentUris method to produce the base URI for the contact with _ID == 23.
Uri myPerson = ContentUris.withAppendedId(People.CONTENT_URI, 23);

// Alterna4vely, use the Uri method to produce the base URI.
// It takes a string rather than an integer.
Uri myPerson = Uri.withAppendedPath(People.CONTENT_URI, "23");

// Then query for this specific record:
Cursor cur = managedQuery(myPerson, null, null, null, null);

import android.database.Cursor;

// Form an array specifying which columns to return.
String[] projec4on = new String[] {
People._ID,
People._COUNT,
People.NAME,
People.NUMBER
};

// Get the base URI for the People table in the Contacts content provider.
Uri contacts = People.CONTENT_URI;

// Make the query.
Cursor managedCursor = managedQuery(contacts,
projec4on, // Which columns to return
null, // Which rows to return (all rows)
null, // Selec4on arguments (none)
// Put the results in ascending order by name
People.NAME + " ASC");

•  Retrieving the data:

private void getColumnData(Cursor cur){
if (cur.moveToFirst()) {

String name;
String phoneNumber;
int nameColumn = cur.getColumnIndex(People.NAME);
int phoneColumn = cur.getColumnIndex(People.NUMBER);
String imagePath;

do {
// Get the field values
name = cur.getString(nameColumn);
phoneNumber = cur.getString(phoneColumn);

// Do something with the values.
...

} while (cur.moveToNext());

}
}

Content Providers: Modifying Data
•  Data kept by a content provider can be modified by:
–  Adding new records
–  Adding new values to exis4ng records
–  Batch upda4ng exis4ng records
–  Dele4ng records
•  All accomplished using ContentResolver methods
•  Use ContentValues() to add or update data

Content Providers: Adding Data
•  Adding new records:
import android.content.ContentResolver;
import android.content.ContentValues;

ContentValues values = new ContentValues();

// Add Abraham Lincoln to contacts and make him a favorite.
values.put(People.NAME, "Abraham Lincoln");
// 1 = the new contact is added to favorites
// 0 = the new contact is not added to favorites
values.put(People.STARRED, 1);

Uri uri = getContentResolver().insert(People.CONTENT_URI, values);

Content Providers: Adding Data
•  Adding new values:
Uri phoneUri = null;
Uri emailUri = null;

phoneUri = Uri.withAppendedPath(uri, People.Phones.CONTENT_DIRECTORY);

values.clear();
values.put(People.Phones.TYPE, People.Phones.TYPE_MOBILE);
values.put(People.Phones.NUMBER, "1233214567");
getContentResolver().insert(phoneUri, values);

// Now add an email address in the same way.
emailUri = Uri.withAppendedPath(uri, People.ContactMethods.CONTENT_DIRECTORY);

values.clear();
// ContactMethods.KIND is used to dis4nguish different kinds of
// contact methods, such as email, IM, etc.
values.put(People.ContactMethods.KIND, Contacts.KIND_EMAIL);
values.put(People.ContactMethods.DATA, "test@example.com");
values.put(People.ContactMethods.TYPE, People.ContactMethods.TYPE_HOME);
getContentResolver().insert(emailUri, values);

Content Providers
•  Use ContentResolver.update() to batch update fields
•  Use ContentResolver.delete() to delete:
–  A specific row
–  Mul4ple rows, by calling the method with the URI of the type of
record to delete and an SQL WHERE clause defining which rows to
delete

Crea4ng Content Providers
•  To create a content provider, you must:
–  Set up a system for storing the data. Most content providers store
their data using Android's file storage methods or SQLite databases,
but you can store your data any way you want.
–  Extend the ContentProvider class to provide access to your data
–  Declare the content provider in the manifest file for your applica4on
(AndroidManifest.xml)

•  Extending the ContentProvider class will require:
–  Implemen4ng the following methods: query(), insert(), update(),
delete(), getType(), onCreate()
–  Make sure that these implementa4ons are thread-‐safe as they may be
called from several ContentResolver objects in several different
processes and threads
•  In addi4on, you need to:
–  Declare a public sta4c final URI named CONTENT_URI
–  Define the column names that the content provider will return to
clients
–  Carefully document the data type of each column

•  You need to declare the content provider in the Manifest file:
•  Example:
<provider android:name="com.example.autos.AutoInfoProvider"
android:authori4es="com.example.autos.autoinfoprovider"
. . . />
</provider>

Storage

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Storage

Uploaded by

Copyright:

Available Formats

Data

COMP 355 (Muppala) Data Storage 2

COMP 355 (Muppala) Data Storage 3

COMP 355 (Muppala) Data Storage 4

COMP 355 (Muppala) Data Storage 5

COMP 355 (Muppala) Data Storage 6

• SeEng user preferences for an applica4on is supported in

COMP 355 (Muppala) Data Storage 7

COMP 355 (Muppala) Data Storage 8

COMP 355 (Muppala) Data Storage 9

COMP 355 (Muppala) Data Storage 10

COMP 355 (Muppala) Data Storage 12

COMP 355 (Muppala) Data Storage 13

COMP 355 (Muppala) Data Storage 14

COMP 355 (Muppala) Data Storage 15

COMP 355 (Muppala) Data Storage 16

COMP 355 (Muppala) Data Storage 17

COMP 355 (Muppala) Data Storage 18

COMP 355 (Muppala) Data Storage 19

COMP 355 (Muppala) Data Storage 20

COMP 355 (Muppala) Data Storage 21

COMP 355 (Muppala) Data Storage 22

COMP 355 (Muppala) Data Storage 23

COMP 355 (Muppala) Data Storage 24

COMP 355 (Muppala) Data Storage 25

COMP 355 (Muppala) Data Storage 27

COMP 355 (Muppala) Data Storage 28

COMP 355 (Muppala) Data Storage 29

COMP 355 (Muppala) Data Storage 30

COMP 355 (Muppala) Data Storage 31

COMP 355 (Muppala) Data Storage 32

COMP 355 (Muppala) Data Storage 33

COMP 355 (Muppala) Data Storage 34

COMP 355 (Muppala) Data Storage 35

COMP 355 (Muppala) Data Storage 36

COMP 355 (Muppala) Data Storage 37

COMP 355 (Muppala) Data Storage 38

COMP 355 (Muppala) Data Storage 39

COMP 355 (Muppala) Data Storage 40

You might also like

•  SeEng user preferences for an applica4on is supported in