Android Application Development

Data Management
Saving Data Storage Option

Options to save persistent application data:

[1] Shared Preferences:
Store private primitive data in key-value pairs.
[2] Internal Storage:
Store private data on the device memory.
[3] External Storage:
Store public data on the shared external storage.
[4] SQLite Databases:
Store structured data in a private database.
[5] Network Connection:
Store data on the web with your network server.
File File Storage

• Represents a file system entity identified by a

pathname
• Storage areas classified as internal or external
• Internal memory usually used for
application private files
• External memory used for public files
File API File Storage

• boolean isDirectory()
• Return true if this File represents a
directory
• String getAbsolutePath()
• Returns the absolute path to this File
• boolean setReadable(boolean readable)
• Sets read permission on this File
• Many others. You can those methods in
documentation.
Writing an Internal File File Storage

// Open file. Get FileOutputStream

FileOutputStream fos =
openFileOutput(fileName, MODE_PRIVATE);
PrintWriter pw = new PrintWriter( new
BufferedWriter(new
OutputStreamWriter(fos)));
// Write to file
pw.println(…);
…
// Close file
pw.close();
Reading an Internal File File Storage

// Open file. Get FileIntputStream

FileInputStream fis =
openFileInput(fileName);
BufferedReader fr = new BufferedReader( new
InputStreamReader(fis)));
// Read from file
While( null! = (line=fr.readLine()) ) {
// Process data
}
// Close file
br.close();
Cache File File Storage

• Cache files are temporary files that may be deleted by

the system when storage is low
• File Context.getCacheDir()
• Returns absolute path to an application-specific
directory that can be used for temporary files
• Files removed when application uninstalled
External Memory Files File Storage

• Removable media may appear/disappear without

warning
• String Environment.getExternalStorageState()
• MEDIA_MOUNTED - present & mounted with
read/write access
• MEDIA_MOUNTED_READ_ONLY - present & mounted
with read-only access
• MEDIA_REMOVED - not present
• Need permission to write external files
• <uses-permission android:name=
“android.permission.WRITE_EXTERNAL_STORAGE" />
External Memory Files (Code) File Storage

private final String fileName = "myIcon.png";

@Override
public void onCreate(Bundle savedInstanceState) {
…
if (Environment.MEDIA_MOUNTED.equals(Environment
.getExternalStorageState())) {
File outFile = new File( getExternalFilesDir(
Environment.DIRECTORY_PICT URES), fileName);
try {
BufferedOutputStream os = new
BufferedOutputStream( new
FileOutputStream(outFile)); BufferedInputStream is =
new BufferedInputStream(getResources()
.openRawResource(R.drawable.icon));
copy(is, os);
} catch (FileNotFoundException e) {
e.printStackTrace(); } } }
External Memory Files (Code…) File Storage

private void copy(InputStream is, OutputStream os) {

final byte[] buf = new byte[1024];
int numBytes;
try {
while (-1 != (numBytes = is.read(buf))) {
os.write(buf, 0, numBytes);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Saving Cache Files File Storage

• Context.getExternalCacheDir() returns a File representing

external storage directory for cache files
• Files removed when application uninstalled
SharedPreferences Preferences

• A persistent map
• Holds key-value pairs of primitive data types
• Automatically managed across application uses
• Often used for long-term storage of customizable
application data such as user preferences, e.g.,
• User ID
• Favorite Wifi networks
SharedPreferences Preferences
SharedPreferences Preferences

1. Preferences in Android are used to keep track of application

and user preferences.
2. In any application, there are default preferences that can
accessed through the PreferenceManagerinstance and its
related method getDefaultSharedPreferences(Context)
3. With the SharedPreferenceinstance one can retrieve the
intvalue of the any preference with the getInt(String key,
intdefVal).
4. In our case, we can modify the SharedPreferenceinstance in
our case using the edit()and use theputInt(String key,
intnewVal)
Activity SharedPreferences Preferences

• Activity.getPreferences (int mode)

• Mode: MODE_PRIVATE,
• MODE_WORLD_READABLE or
• MODE_WORLD_WRITEABLE
• Returns a SharedPreference object for the current Activity
Application SharedPreferences Preferences

• Context.getSharedPreferences (String name, int mode)

• name – name of SharedPreference file
• mode – MODE_PRIVATE,
MODE_WORLD_READABLE or
MODE_WORLD_WRITEABLE
• Returns named SharedPreference object for this context
Writing SharedPreferences Preferences

• Call SharedPreferences.edit()
• Returns a SharedPreferences.Editor instance
• Add values with SharedPreferences.Editor
• Commit values with
• SharedPreferences.Editor.commit()
Reading SharedPreferences Preferences

• Use SharedReferences methods, e.g.,

• getAll()
• getBoolean()
• getString()
SharedPreferences Preferences

public class SharedPreferenceReadWriteActivity extends

Activity{ private static String HIGH_SCORE = "high_score";
public void onCreate(Bundle savedInstanceState) {
…
final SharedPreferences prefs =
getPreferences(MODE_PRIVATE);
final TextView highScoreText = (TextView)
findViewById(R.id.highScoreTextView);
highScoreText.setText(String.valueOf(prefs.getInt(HIGH_SCO
RE, 0)));
final TextView playText = (TextView)
findViewById(R.id.textView2);
final Button go = …
public void onClick(View v) {
SharedPreferences Preferences

public void onClick(View v) {

Random r = new Random();
int val= r.nextInt(1000);
playText.setText(String.valueOf(val));
if (val > prefs.getInt(HIGH_SCORE, 0)) {
highScoreText.setText(String.valueOf(val));
SharedPreferences.Editor editor = prefs.edit();
editor.putInt(HIGH_SCORE, val);
editor.commit();
}
}
Preferences Activity Preferences

• Class that supports displaying & modifying user

preferences
• deprecated in API Level 11.
• Now we use Fragements.
SharedPreferences (Cont.) Preferences

public class PreferencesActivityExample extends Activity {

SharedPreferences prefs;
final static String USERNAME = "uname";
public void onCreate(Bundle savedInstanceState) { …
prefs = PreferenceManager
.getDefaultSharedPreferences(this);
final Button button = …
public void onClick(View v) {
startActivity(new Intent(
PreferencesActivityExample.this,
LoadPreferencesActivity.class));
} });
}
SharedPreferences (Cont.) Preferences

public class LoadPreferencesActivity extends PreferenceActivity

{
final SharedPreferences prefs = PreferenceManager
.getDefaultSharedPreferences(this);
addPreferencesFromResource(R.xml.user_prefs);
final EditTextPreference uNamePref = (EditTextPreference)
getPreferenceScreen() .findPreference(
PreferencesActivityExample.USERNAME);
uNamePref.setSummary(prefs.getString(PreferencesActivityEx
ample.USERNAME, ""));
prefs.registerOnSharedPreferenceChangeListener(new
OnSharedPreferenceChangeListener() {
@Override
public void onSharedPreferenceChanged(SharedPreferences
sharedPreferences,String key) {
uNamePref.setSummary(prefs.getString(PreferencesActivityEx
ample.USERNAME, ""));
}
}); } }
user_prefs.xml Preferences

<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android"
android:key = "@+id/pref_screen">
<EditTextPreference
android:negativeButtonText="Cancel"
android:dialogMessage="Enter Your User Name"
android:dialogTitle="User Name"
android:positiveButtonText="Submit"
android:title="User Name" android:key="uname">
</EditTextPreference>
</PreferenceScreen>
SQLite Database SQLite

1. Saving Data into Database

a) Introduction to SQLite
b) SQLiteOpenHelper: Database Creation
c) CRUD [Create Read Update Delete]
2. Using a Pre-populated Database
3. Some optimizations
Saving Data into a Database Database SQLite

SQLite is a software library that implements SQL database engine

1. Self-contained:
Requires very minimal support from external libraries or from
the operating system. (well suited for embedded devices)
2. Serverless:
No separate server process like most SQL database implementations
(MySql, Oracle etc.). The process that wants to access the database reads
and writes directly from the database files on disk.
3. Zero-configuration:
Does not need to be "installed". There is no "setup" procedure. There is no
server process that needs to be started, stopped, or configured. No need
for an administrator to create a new database instance or assign access
permissions to users.
4. Transactional:
All changes and queries appear to be Atomic, Consistent, Isolated, and
Durable (ACID)
Saving Data into a Database Database SQLite

Features:
1. Self-contained, Serverless, Zero-configuration and Transactional
2. A complete database is stored in a single cross-platform disk file.
3. Supports terabyte-sized databases and gigabyte-sized strings and blobs.
4. Small code footprint
5. Faster than popular client/server database engines for most operations.
6. Simple, easy to use API.
7. Written in ANSI-C.
8. Cross-platform: Unix (Linux, Mac OS-X, Android, iOS) and Windows
(Win32, WinCE, WinRT) are supported out of the box. Easy to port t
other systems.
9. Sources are in the public domain. Use for any purpose.
10. Comes with a standalone command-line interface (CLI) client that can
be used to administer SQLite databases.
Saving Data into a Database Database SQLite

Basic database concepts:

1. What is SQL?
SQL stands for Structured Query Language
SQL lets you access and manipulate databases
2. What Can SQL do?
SQL can execute queries against a database
SQL can retrieve data from a database
SQL can insert records in a database
SQL can update records in a database
SQL can delete records from a database
SQL can create new databases
SQL can create new tables in a database
SQL can create stored procedures in a database
SQL can create views in a database
SQL can set permissions on tables, procedures, and views
Saving Data into a Database Database SQLite

3. Relational Database Management System (RDBMS)

1. RDBMS stands for Relational Database Management
System.
2. RDBMS is the basis for SQL, and for all modern
database systems such as MS SQL Server, IBM DB2,
Oracle, MySQL, Microsoft Access and SQLite.
3. The data in RDBMS is stored in database objects called
tables.
4. A table is a collection of related data entries and it
consists of columns and rows.
Saving Data into a Database Database SQLite

3. RDBMS Example
Saving Data into a Database Database SQLite

3. RDBMS Example
Saving Data into a Database Database SQLite

5. Database Operations 6. SQL Commands

1. Database creation SELECT - extracts data from a database
2. Table(s) creation UPDATE - updates data in a database
3. Insert Record(s) DELETE - deletes data from a database
4. Update Record(s)
INSERT INTO - inserts new data into a database
5. Delete Record(s)
CREATE DATABASE - creates a new database
6. Query
ALTER DATABASE - modifies a database
7. Drop Table(s)
8. Alter Table(s) CREATE TABLE - creates a new table
ALTER TABLE - modifies a table
DROP TABLE - deletes a table
CREATE INDEX - creates an index (search key)
DROP INDEX - deletes an index
SQLite Android Database SQLite
Table Creation Database SQLite

CREATE TABLE IF NOT EXISTS `employee` (

`EmployeeID` int(11) NOT NULL
AUTO_INCREMENT,
`Name` varchar(50) NOT NULL,
`Address` varchar(100) NOT NULL,
`PhoneNumber` varchar(11) NOT NULL,
`Designation` varchar(50) NOT NULL,
PRIMARY KEY (`EmployeeID`)
);
Insert Record Database SQLite

INSERT INTO employee (EmployeeID, Name,

Address, PhoneNumber, Designation) VALUES
(NULL, 'Hasan', 'Mirpur, Dhaka',
'01745534',
'Developer');

INSERT INTO employee (EmployeeID, Name,

Address, PhoneNumber, Designation) VALUES
(NULL, 'Rahim', 'Motijheel, Dhaka',
'01956635',
'Designer');
Query Record Database SQLite

SELECT * FROM employee;

SELECT Name, Address FROM employee;
SELECT * FROM employee WHERE EmployeeID =
1;
SELECT * FROM employee WHERE Designation
=
‘Developer’;
Saving Data into a Databases SQLite in Android
Opening a Database (Android code) Database SQLite

public class DatabaseOpenHelper extends

SQLiteOpenHelper {
final private static String CREATE_CMD =
"CREATE TABLE artists (" +
DatabaseExampleActivity._ID + " INTEGER
PRIMARY KEY AUTOINCREMENT, " +
DatabaseExampleActivity.ARTIST_NAME + " TEXT
NOT NULL)";
final private static String NAME = "artist_db";
final private static Integer VERSION = 1;
public DatabaseOpenHelper(Context context) {
super(context, NAME, null, VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(CREATE_CMD); }
Using a Database (Android code) Database SQLite

public class DatabaseOpenHelper extends

SQLiteOpenHelper {
final private static String CREATE_CMD =
"CREATE TABLE artists (" +
DatabaseExampleActivity._ID + " INTEGER
PRIMARY KEY AUTOINCREMENT, " +
DatabaseExampleActivity.ARTIST_NAME + " TEXT
NOT NULL)";
final private static String NAME = "artist_db";
final private static Integer VERSION = 1;
public DatabaseOpenHelper(Context context) {
super(context, NAME, null, VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(CREATE_CMD); }
Using a Database (Android code) Database SQLite

public class DatabaseExampleActivity extends

ListActivity {
final static String TABLE_NAME = "artists";
final static String ARTIST_NAME = "name";
final static String _ID = "_id";
final static String[] columns = { _ID, ARTIST_NAME};
static SQLiteDatabase db = null;
Using a Database (Android code) Database SQLite

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);
DatabaseOpenHelper dbHelper = new
DatabaseOpenHelper(this); db =
dbHelper.getWritableDatabase(); insertArtists();
deleteLadyGaga();
Cursor c = readArtists();
setListAdapter(new SimpleCursorAdapter(this,
R.layout.list_layout, c, columns, new
int[] { R.id._id, R.id.name }));
}
Using a Database (Android code) Database SQLite

private void insertArtists() {

ContentValues values = new ContentValues();
values.put(ARTIST_NAME, "Lady Gaga");
db.insert(TABLE_NAME, null, values);
values.clear();
values.put(ARTIST_NAME, "Johnny Cash");
db.insert(TABLE_NAME, null, values);
values.clear();
values.put(ARTIST_NAME, "Ludwig von
Beethoven");
db.insert(TABLE_NAME, null, values);
}
Using a Database (Android code) Database SQLite

private Cursor readArtists() {

return db.query(TABLE_NAME, columns, null, new
String[] {}, null, null, null);
}
private int deleteLadyGaga() {
return db.delete(TABLE_NAME,ARTIST_NAME+"=?",
new String [] {"Lady Gaga"});
}