Data Storage in Android

Lecturer: Trần Hồng Nghi

Email: [email protected]
Android Files
Android uses the same file constructions found in
a typical Java application.
Files can be stored in the device’s (small) main
memory or in the much larger SD card. They can
also be obtained from the network (as we will see
later).
Files stored in the device’s memory, stay together
with other application’s resources (such as icons,
pictures, music, …).
We will call this type: Resource Files.
Storage Options
Android provides several options for you to save persistent
application data. The solution you choose depends on your
specific needs, such as whether the data should be private to
your application or accessible to other applications (and the
user) and how much space your data requires.
Your data storage options are the following:
• Shared Preferences: Store private primitive data in key-value
pairs.
• Internal Storage: Store private data on the device memory.
• External Storage: Store public data on the shared external storage.
• SQLite Databases: Store structured data in a private database.
• Network Connection: Store data on the web with your own
network server.
Shared Preferences
Preferences is an Android lightweight mechanism
to store and retrieve <key-value> pairs of
primitive data types: booleans, floats, ints, longs,
and strings
PREFERENCES are typically used to keep state
information and shared data among several
activities of an application.
In each entry of the form <key-value> the key is
a string and the value must be a primitive data
type.
Preferences are similar to Bundles however they
are persistent while Bundles are not.
Shared Preferences(cont.)
To get access to the preferences, you can use the
following APIs:
 getPreferences() from within your Activity, to access
activityspecific preferences
 getSharedPreferences() from within your Activity (or other
application Context), to access application-level preferences
getDefaultSharedPreferences(), onPreferencesManager, to
get the shared preferences that work in concert with
Android’s overall preference framework
All of these methods return an instance of
SharedPreferences, which offers a series of getters to
access named preferences, returning a suitably typed
result (e.g., getBoolean() to return a Boolean preference).
Preference access permissions
You can open and create SharedPreferences with
any combination of several Context mode
constants. Because these values are int types,
you can add them, to combine permissions. The
following mode constants are supported:
 Context.MODE_PRIVATE (value 0)
 Context.MODE_WORLD_READABLE (value 1)
 Context.MODE_WORLD_WRITEABLE (value 2)
 Using Preferences API calls(cont.)
To write values:
1. Call edit() to get a SharedPreferences.Editor.
2. Add values with methods such as putBoolean() and
putString().
3. Commit the new values with commit()
To read values, use SharedPreferences methods
such as getBoolean() and getString().

//get the preferences, then editor, set a data //get the preferences then retrieve
item saved data, specifying a default value
SharedPreferences appPrefs = SharedPreferences appPrefs =
getSharedPreferences("MyAppPrefs", 0); getSharedPreferences("MyAppPrefs",
SharedPreferences.Editor prefsEd = 0);
appPrefs.edit(); String savedData =
prefsEd.putString("dataString", "some string appPrefs.getString("dataString", "");
data");
prefsEd.commit();
Using Preferences API calls(cont.)
 Path of Preferences xml file.
Android puts SharedPreferences XML files in the
/data/data/YOUR_PACKAGE_NAME/shared_prefs/YOUR_PR
EFS_NAME.xml
OR
/data/data/YOUR_PACKAGE_NAME/shared_prefs/YOUR_PA
CKAGE_NAME_preferences.xml
An application or package usually has its own:
 Example
Saving/Retrieving a SharedPreference Object holding
UI user choices.
 Example(cont.)

Using DDMS to explore the Device’s memory map. Observe the choices
made by the user are saved in the data/data/Shared_prefs/ folder as an
XML file.
File xml
Example(cont.)
Example(cont.)
Example(cont.)
Example(cont.)
 Internal Storage:
You can save files directly on the device's internal storage. By default,
files saved to the internal storage are private to your application and
other applications cannot access them (nor can the user). When the
user uninstalls your application, these files are removed.
Android provides a convenience method on Context to get a
FileOutputStream— namely openFileOutput(String name, int mode)
create and write a private file to the internal storage:
1. Call openFileOutput() with the name of the file and the operating
mode. This returns a FileOutputStream. That file will ultimately be
stored at the data/data/[PACKAGE_NAME]/files/file.name path on
the platform.
2. Write to the file with write().
3. Close the stream with close().
 MODE_PRIVATE
MODE_PRIVATE will create the file (or replace a file
of the same name) and make it private to your
application. Other modes available are:  MODE_APPEND
, MODE_WORLD_READABLE,  MODE_WORLD_WRITEABLE.
Tip: If you want to save a static file in your
application at compile time, save the file in your
project res/raw/directory. You can open it with 
openRawResource(), passing
the R.raw.<filename> resource ID. This method
returns an InputStream that you can use to read the
file (but you cannot write to the original file).
Saving cache file
If you'd like to cache some data, rather than store it
persistently, you should use getCacheDir() to open a 
Filethat represents the internal directory where your
application should save temporary cache files.
When the device is low on internal storage space,
Android may delete these cache files to recover space.
However, you should not rely on the system to clean
up these files for you. You should always maintain the
cache files yourself and stay within a reasonable limit
of space consumed, such as 1M.
When the user uninstalls your application, these files
are removed.
Other useful methods
getFilesDir() Gets the absolute path to the
filesystem directory where your internal files are
saved.
getDir()Creates (or opens an existing) directory
within your internal storage space.
deleteFile()Deletes a file saved on the internal
storage.
fileList()Returns an array of files currently saved
by your application.
 Using Android Resource Files
When an application’s .apk bytecode is deployed it may store
in memory: code, drawables, and other raw resources (such
as files). Acquiring those resources could be done using a
statement such as:
External Storage
Every Android-compatible device supports a shared "external storage"
that you can use to save files. This can be a removable storage media
(such as an SD card) or an 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.
Before you do any work with the external storage, you should always
call getExternalStorageState() to check whether the media is available.
The media might be mounted to a computer, missing, read-only, or in
some other state.
Caution: External storage can become unavailable if the user mounts
the external storage on a computer or removes the media, and there's
no security enforced upon files you save to the external storage. All
applications can read and write files placed on the external storage
and the user can remove them.
 External Storage(cont.)

SDK1.6 it is necessary to request permission to write to the SD card. Add the following
clause to your AndroidManifest.xml
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE">
</uses-permission>
Example: Checking media availability
Example: Create file on External Storage
Accessing files on external storage
Using API Level 8 or greater, use getExternalFilesDir() to open a File that
represents the external storage directory .
This method takes a type parameter that specifies the type of subdirectory
you want, such as:  
 DIRECTORY_MUSIC 
  DIRECTORY_RINGTONES 

This method will create the appropriate directory if necessary. By specifying the
type of directory, you ensure that the Android's media scanner will properly
categorize your files in the system (for example, ringtones are identified as
ringtones and not music).
Using API Level 7 or lower, use getExternalStorageDirectory(), to open a File
 representing the root of the external storage. You should then write your
data in the following directory:
/Android/data/<package_name>/files/
The <package_name> is your Java-style package name, such as
"com.example.android.app“.
• If the user uninstalls your application, this directory and all its contents will be
deleted.
Saving files that should be shared
If you want to save files that are not specific to your application and that
should not be deleted when your application is uninstalled, save them to one
of the public directories on the external storage. These directories lay at the
root of the external storage, such as Music/, Pictures/, Ringtones/, and others.
In API Level 8 or greater, usegetExternalStoragePublicDirectory() else
 use getExternalStorageDirectory() to open a File.
Save your shared files in one of the following directories:
Music/ - Media scanner classifies all media found here as user music.
Podcasts/ - Media scanner classifies all media found here as a podcast.
Ringtones/ - Media scanner classifies all media found here as a ringtone.
Alarms/ - Media scanner classifies all media found here as an alarm sound.
Notifications/ - Media scanner classifies all media found here as a notification
sound.
Pictures/ - All photos (excluding those taken with the camera).
Movies/ - All movies (excluding those taken with the camcorder).
Download/ - Miscellaneous downloads.
 Saving cache files
using API Level 8 or greater, use 
getExternalCacheDir() to open a File that represents
the external storage directory where you should save
cache files. If the user uninstalls your application,
these files will be automatically deleted.
If you're using API Level 7 or lower, use 
getExternalStorageDirectory() to open a File that
represents the root of the external storage, then
write your cache data in the following directory:
/Android/data/<package_name>/cache/
The <package_name> is your Java-style package
name, such as "com.example.android.app".
Content Provider & SQLite
Content Provider
SQLite
 Content Provider
 Content providers allow programs access to data which is present
on the device.

 A content provider manages access to a central repository of data.

 They encapsulate the data from tables, and provide mechanisms

for defining data security and unified usage.

 Content providers are the standard interface that connects data in

one process with code running in another process.
 Link Content Provider:
http://developer.android.com/reference/android/provider/package-
summary.html
30
Content Providers available
Content Provider Intended Data

Browser Browser bookmarks, browser

history, etc.

CallLog Missed calls, call details, etc.

Contacts Contact details

MediaStore Media files such as audio, video

and images

Settings Device settings and preferences

How they work
Irrespective of how the data is stored, Content Providers
give a uniform interface to access the data.

Data is exposed as a simple table with rows and columns

where row is a record and column is a particular data type
with a specific meaning.

Each record is identified by a unique _ID field which is

the key to the record.

Each content provider exposes a unique URI that

identifies its data set uniquely. URI == table-name
 Content Provider-Cursor
 Cursor is an interface that provides random read-write access
to the result of a database query from a content provider
 A cursor is a collection of rows

ID ISBN Tên sách NXB

1 123456 Lập trình Android T3H
2 987654 Lập trình iPhone T3H
3 134679 Lập trình Java T3H1
4 258456 Lập trình C# T3H2

Get books: T3H

Cursor
ID ISBN Title NXB
1 123456 Lập trình Android T3H
2 987654 Lập trình iPhone T3H
33
 Method of Cursor:
moveToFirst
moveToNext
moveToPrevious
getCount
getColumnIndexOrThrow
getColumnName
getColumnNames
moveToPosition
getPosition

34
Content URI
A content URI is a URI that identifies data in a
provider.

 android.provider.Contacts.Phones.CONTENT_URI
 android.provider.Contacts.Photos.CONTENT_URI
 Content Provider
ContentResolver
 ContentResolver cr = getContentResolver();

To retrieve data from a provider, your application

needs "read access permission" for the provider in
androidmanifest.xml
Cusor:
 Cursor cursor = cr.query(…)
Ex: Cursor someRows = cr.query(MyProvider.CONTENT_URI,
null, where, null, order);

36
 Content Provider
ContentResolver cr = getContentResolver();

// Trả về các dòng

Cursor allRows = cr.query(MyProvider.CONTENT_URI, null, null, null,
null);

// Trả về những dòng có cột thứ 3 bằng giá trị cho trước
// và theo thứ tự của cột thứ 5
String where = KEY_COL3 + "=" + requiredValue;
String order = KEY_COL5;

Cursor someRows = cr.query(MyProvider.CONTENT_URI,

null, where, null, order);

37
Example: contact
Activity_main.xml
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" >

<ListView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/lv"
></ListView>

</RelativeLayout>
Example row.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/textName"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>
<TextView
android:id="@+id/textValue"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>
</LinearLayout>
Example
Set permission to access data
<uses-permission
android:name="android.permission.RE
AD_CONTACTS"/>
Example
MainActivity.java
SQLite
SQLite Databases:
SQLite is an open source database that is stable, and
is popular on many small devices, including Android.
SQLite is a great fit for Android app development:
 It’s a zero-configuration database.
 It doesn’t have a server.
 It’s a single-file database.
 It’s open source

Available in all Android device

No separate setup or administration
Embedded in Android
Database Dir:
DATA/data/APP_NAME/databases/FILENAME
Android Package
Packages
android.database
android.database.sqlite

Classes
SQLiteOpenHelper
To manage database creation, and version management.
http://developer.android.com/reference/android/database/sqlite/SQLi
teOpenHelper.html

SQLiteDatabase
To manage SQLite DB
http://developer.android.com/reference/android/database/sqlite/SQLi
teDatabase.html
 Database Location
Emulator’s File Explorer showing the placement of the
database
SQLite statement
Create table
create table <name table>( Colum 1 <Data type >,
Colum 2<Data type >,
Colum 3<Data type >,
. . . . . . .);
Insert data
insert into <name table > [(colum)] values(<value>);
● Delete data
Delete from < name table > [where <condition> ];
● Update
Update <name table> set <colum name>=<value>[,< colum name
t>=< value >, . . ]
[where <condition>];
 How to create a SQLite database?
Method 1

Open the database according to the flags OPEN_READWRITE, OPEN_READONLY

,CREATE_IF_NECESSARY . Sets the locale of the database to the the system's current locale.
Parameters

path to database file to open and/or create

factory an optional factory class that is called to instantiate a cursor

when query is called, or null for default
flags to control database access mode

Returns the newly opened database

Throws SQLiteException if the database cannot be opened

Example Create a SQLite Database
Example Create a SQLite Database(cont.)
Example Create a SQLite Database(cont.)
 create a SQLite database(cont.)
An alternative way of opening/creating a SQLITE
database in your local Android’s System Image is given
below:

1. “myFriendsDB2” is the abbreviated file path. The prefix is assigned by

Android as: /data/data/<app namespace>/databases/myFriendsDB2.
2. MODE could be: MODE_PRIVATE, MODE_WORLD_READABLE, and
MODE_WORLD_WRITEABLE. Meaningful for apps consisting of
multiples activities.
3. null refers to optional factory class parameter
Cursors
Android cursors are used to gain (random) access to tables
produced by SQL select statements.
Cursors primarily provide one row-at-the-time operations on a
table.
Cursors include several types of operator, among them:
1. Positional awareness operators (isFirst(), isLast(),
isBeforeFirst(), isAfterLast() ),
2. Record Navigation (moveToFirst(), moveToLast(),
moveToNext(), moveToPrevious(), move(n) )
3. Field extraction (getInt, getString, getFloat, getBlob,
getDate, etc.)
4. Schema inspection (getColumnName, getColumnNames,
getColumnIndex, getColumnCount, getCount)
 Creating-Populating a Table
SQL Syntax for the
creating and
populating of a
table looks like this:
 Creating-Populating a Table(cont.)
We will use the execSQL(…) method to manipulate SQL action
queries. The following example creates a new table called
tblAmigo.
The table has three fields: a numeric unique identifier called
recID, and two string fields representing our friend’s name and
phone. If a table with such a name exists it is first dropped and
then created anew. Finally three rows are inserted in the table.
Comments
1. The field recID is defined as PRIMARY KEY of the table.
The “autoincrement” feature guarantees that each new
record will be given a unique serial number (0,1,2,…).
2. The database data types are very simple, for instance
we will use: text, varchar, integer, float, numeric, date,
time, timestamp, blob, boolean, and so on.
3. In general, any well-formed SQL action command
(insert, delete, update, create, drop, alter, etc.) could
be framed inside an execSQL(…) method.
4. You should make the call to execSQL inside of a try-
catch-finally block. Be aware of potential
SQLiteException situations thrown by the method.
QUERY vs RAW QUERY

 Raw Query take for input a syntactically correct SQL-select

statement. The select query could be as complex as needed and
involve any number of tables (remember that outer joins are
not supported).
 Query are compact parametized select statements that operate
on a single table (for developers who prefer not to use SQL).
 rawQuery(String query , String[] array);
 Query(String table, String[] columns, String selection, String[]
selectionArgs, String groupBy, String having, String orderBy,
String limit)
 execSQL(String sql)
Execute a single SQL statement that is NOT a SELECT or any
other SQL statement that returns data.
QUERY vs RAW QUERY

RAW QUERY QUERY

String query = “select * String[] cols =

from student_demo where {“_id”,”s_name”};
_id = ? And age > ? Order String[] params =
by s_name limit ?”; {“1,”23”};
Cursor c = db.rawQuery( Cursor c =
query, new String[] db.query(“student_demo”,
{“1”,”23”,”5”} cols,”_id = ? And age
); = ?”,params,null,
Null,5
);
 RAW QUERY
Consider the following code fragment

The previous rawQuery contains a select-statement that counts the

rows in the table tblAMIGO.
The result of this count is held in a table having only one row and
one column. The column is called “Total”.
The cursor c1 will be used to traverse the rows (one!) of the resulting
table.
Fetching a row using cursor c1 requires advancing to the next record
in the answer set.
Later the (singleton) field total must be bound to a local Java
variable.
 RAW QUERY(Cont.)
Assume we want to count how many friends are
there whose name is ‘BBB’ and their
recID > 1. We could use the following construction
 SIMPLE QUERY
The signature of the
Android’s simple
query method is:
 Using SQLITE Command Line
The Android SDK contains a command line interface to SQLITE
databases.
To open/Create a database use the command
C:> sqlite3 myNewDatabase
You may directly reach the Emulator’s data folder and operate on
existing databases.
Assume an emulator is running.
We will use adb shell to tap in the emulator’s internal memory
Summary of SQLITE3 commands
Summary of SQLITE3 commands(Cont.)
Summary of SQLITE3
commands(Cont.)
Example
 Move, copy database
In order to move a copy of the database in and out of
the Emulator’s storage space and either receive or send
the file into/from the local computer’s file system you
may use the commands:
• adb pull <full_path_to_database>
• adb push <full_path_to_database>
You may also use the Eclipse’s DDMS Perspective to
push/pull files in/out the emulator’s file system.
Once the database is in your computer’s disk you may
manipulate the database using a ‘user-friendly’ tool
such as:
• SQLite Manager (Firefox adds-on)
• SQLite Administrator (http://sqliteadmin.orbmu2k.de)
GUI Tool
 Copy database in project
Copy database file to /assets directory
Create class DatabaseHelper extend SQLiteOpenHelper in
package “android.database.sqlite”.
createDataBase() to copy database file.
EX: public class DataBaseHelper extends SQLiteOpenHelper{
private static String DB_PATH =
"/data/data/YOUR_PACKAGE/databases/";
//tên file cơ sở dữ liệu
private static String DB_NAME = "myDBName";
private SQLiteDatabase myDataBase;
private final Context myContext;
public DataBaseHelper(Context context) {
super(context, DB_NAME, null, 1);
this.myContext = context;
}
Copy database in project(cont.)
public void createDataBase() private boolean checkDataBase(){
throws IOException{ SQLiteDatabase checkDB = null;
boolean dbExist = try{
checkDataBase(); String myPath = DB_PATH +
if(dbExist){ DB_NAME;
return; checkDB =
}else{ SQLiteDatabase.openDatabase(myPa
this.getReadableDatabase(); th, null,
try { SQLiteDatabase.OPEN_READONLY
copyDataBase(); );
} catch (IOException e) { }catch(SQLiteException e){
throw new Error("Error copying //database does't exist yet.
database"); }
} if(checkDB != null){
} checkDB.close();
}
return checkDB != null ? true : false;
}
 Copy database in project(cont.)
public void openDataBase() throws
SQLException{
private void copyDataBase()
String myPath = DB_PATH +
throws IOException{
DB_NAME;
InputStream myInput =
myDataBase =
myContext.getAssets().open(DB_N
SQLiteDatabase.openDatabase(myPath,
AME);
null,
String outFileName = DB_PATH +
SQLiteDatabase.OPEN_READONLY);
DB_NAME;
}
OutputStream myOutput = new
@Override
FileOutputStream(outFileName);
public synchronized void close() {
byte[] buffer = new byte[1024];
if(myDataBase != null)
int length;
myDataBase.close();
while ((length =
super.close();
myInput.read(buffer))>0){
}
myOutput.write(buffer, 0, length);
@Override
}
public void onCreate(SQLiteDatabase db) {
myOutput.flush();
}
myOutput.close();
@Override
myInput.close();
public void onUpgrade(SQLiteDatabase db,
int oldVersion, int newVersion)
References
Book: Android in Action
The Busy Coder's Guide to Android Development
by Mark L. Murphy
Slide of Victor Matos
http://developer.android.com/