Android Data Storage

Srilakshmi.N

Mobile Application Developer

Symbioun Software Pvt Ltd

Agenda

• Android Data Storage Introduction

• Shared Preferences

• Internal Storage

• External Storage

• SQLite Database

• Sample Examples

Introduction

• In order to maintain the essential information across Application-Executions or Life Time Of the Application .

• Android provides several options for you to save persistent application data using Android Data Storage .

Shared Preferences

•Store private primitive data in key-value pairs.

Shared Preferences

• Syntax: SharedPreferences sharedpreferences = getSharedPreferences(MyPreferences, Context.MODE_PRIVATE);

• Shared preferences Data is stored in XML file in the directory data/data/<package name>/shared-prefs/pref.xml

Shared Preferences

• MODE_PRIVATE: only your app can access the file

• MODE_MULTI_PROCESS: Multiple processes can modify the same shared prefernce file

MODE_PRIVATEMODE_WORLD

_READABLE

MODE_WORLD_WRITABLE

MODE_MULTI_PROCESS

Accessing Modes:

To get a SharedPreferences object for your application, use one of two methods:

• getSharedPreferences() - Use this if you need multiple

preferences files identified by name, which you

specify with the first parameter.

• getPreferences() - Use this if you need only one

preferences file for your Activity. Because this will be

the only preferences file for your Activity, you don't

supply a name.

Accessing Shared Preferences

Shared Preferences

To write values:

•Call edit() to get a sharedpreferences.Editor

•Add values with methods such as putBoolean() and putString()

•Commit the new values with commit()

Shared Preferences Example

Shared Preferences Example

• OutPut

public class ActivityA extends Activity{

EditText username, password;

@Override

protected void onCreate(Bundle savedInstanceState){

super.onCreate(savedInstsanceState);

setContentview(R.layout.activity_mainA);

username=(EditText) findViewById(R.id.edt1);

password=(EditText) findViewById(R.id.edt2); }

public void save(View view) {

SharedPreferences sp=getSharedPreferences(“Preferencename” MODE_PRIVATE);

SharedPreferences.Editor editor = SharedPreferences.edit();

Editor.putString(“name” “username.getText().toString() ”);

Editor.putString(“password” “password.getText().toString()”) ; }

public void next(View view) {

Toast.makeText(this,"Next" ,Toast.LENGHT_LONG).show();

Intent intent= new Intent(this,ActivityB.class);

startActivity(intent); } }

Example:

public class ActivityB extends Activity{

TextView username, password;

@Override

protected void onCreate(Bundle savedInstanceState){

super.onCreate(savedInstsanceState);

setContentview(R.layout.activity_mainB);

username=(TextView) findViewById(R.id.txt1);

password=(TextView) findViewById(R.id.txt2); }

public void load(View view) {

SharedPreferences sp=getSharedPreferences(“Preferencename” MODE_PRIVATE);

String name=Sharedpreferences.getString(“name” “Default ”);

String password=Sharedpreferences.getString(“password” “Default ”);

username.setText(name);

Password.setText(password);}

public void previous(View view) {

Toast.makeText(this,"Next" ,Toast.LENGHT_LONG).show();

Intent intent= new Intent(this,ActivityA.class);

startActivity(intent) } }

Using the Internal Storage

Internal Storage – Store Private data on device memory.

To create and write a private file to the

internal storage:

1. Call openOutput() with the name of the file

and operating mode. It Returns

FileOutPutStream.

2. Write to the file with write()

3. Close the stream with close()

Example:

String FILENAME = "hello_file";

String string = "hello world!";

FileOutputStream fos = openFileOutput(FILENAME, Context.MODE_PRIVATE);

fos.write(string.getBytes());

fos.close();

Note:To store static file save the file in your project res/raw/ directory. 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).

Internal Storage

To read a file from internal storage:

•Call openFileInput() and pass it the name of the file to read. This returns a FileInputStream.

•Read bytes from the file with read().

•Then close the stream with close().

Saving cache files

• If you'd like to cache some data, rather than store it persistently, you should use getCacheDir() to open a File that represents the internal directory where your application should save temporary cache files.

•Cache files are the temperary files.

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.

External Storage(SD Card)

Externnal Storage - Store public data on the shared

external storage.

Getting access to external storageIn order to read or write files on the external storage, your app must acquire the READ_EXTERNAL_STORAGE orWRITE_EXTERNAL_STORAGE system permissions.

For example:

<manifest ...><uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

...</manifest>

/* Checks if external storage is available for read and write */

public boolean isExternalStorageWritable() {

String state = Environment.getExternalStorageState();

if (Environment.MEDIA_MOUNTED.equals(state)) {

return true;

}

return false;

}

/* Checks if external storage is available to at least read */

public boolean isExternalStorageReadable() {

String state = Environment.getExternalStorageState();

if (Environment.MEDIA_MOUNTED.equals(state) ||

Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {

return true;

}

return false;

}

Example

SD Card

Checking Media Availability:

You should always call getExternalStorageState() to check whether the media is available or not.

Syntax: /* Checks if external storage is available for read and write */

public boolean isExternalStorageWritable() {

String state = Environment.getExternalStorageState();

if (Environment.MEDIA_MOUNTED.equals(state)) {

return true;

}

return false;

}

Saving files that can be shared with other apps• For example, here's a method that creates a directory for a

new photo album in the public pictures directory:

Example:

public File getAlbumStorageDir(String albumName) {

// Get the directory for the user's public pictures directory.

File file = new File(Environment.getExternalStoragePublicDirectory(

Environment.DIRECTORY_PICTURES), albumName);

if (!file.mkdirs()) {

Log.e(LOG_TAG, "Directory not created");

}

return file;

}

SQLite Database

SQLite Database - Store structured data in a private database.

• programmatically created SQLite database of an app is always stored in /data/data/<package>/databases folder with ( .db extension).

Saving files that can be shared with other apps

• To get a File representing the appropriate public directory, call getExternalStoragePublicDirectory(), passing it the type of directory you want, such as DIRECTORY_MUSIC, DIRECTORY_PICTURES, DIRECTORY_RINGTONES, or others.

• Syntax: File file = new File(Environment.getExternalStoragePublicDirectory(

Environment.DIRECTORY_PICTURES), albumName);

SQLite Database Process Architecture

SQLite Database

•Creating SQL object

Step:1 Importing package “android.database.sqlite.SQLiteDatabase”.

Step:2 Creating object

SQLiteDatabase object name=null;

SQLite Database

Creating Database Name

mydb=openOrCreateDatabase("DatabaseName5",

MODE_PRIVATE,null);

// mydb is sqlite object name .

// DatabaseName5 is nothing but database name

// MODE_PRIVATE is permissions of a table accessing

SQLite DatabaseDDL Statements – These statements are used to perfrom operations on schemas.They are

• Create• Alter• Drop

DML Statements – these statements are used to perform operations on the data present in schemas.Theyare

• Select• Insert• Delete

Creating Table Create:

mydb.execSQL("CREATE TABLE IF NOT EXISTS “ +TableName+" (ColumnName DataType);");Alter:

ALTER TABLE TableName RENAME TO new-table-nameDrop: DROP TABLE TableName

SQLite Database

• DDL Statements and syntax:

Create:Creates Schema with name

mydb.execSQL("CREATE TABLE IF NOT EXISTS “ +TableName+" (ColumnName DataType);");

Alter: Alters the name of the schema

ALTER TABLE TableName RENAME TO new-table-name

Drop: Drops the schema

DROP TABLE TableName

SQLite Database•DDL Statements and Syntax:

Select: To select particular data in schema

Cursor c=mydb.rawQuery("SELECT * FROM "+TableName+" where Name='"+city+"'",null);

Insert: To insert some data into schema

mydb.execSQL("INSERT INTO "+TableName+“ (Name, Area)“ + "VALUES ('RedFort','40.8 acres‘);");

Delete:To delete data

mydb.execSQL(“Delete"+TableName);

Note:The Cursor is always the mechanism with which you can navigate results from a database query and read rows and columns.

SQLite Database

• SQLite OpenHelper is a class to manage database creation and version management.

• This class take care of opening the database if it exists, creating it if it does not, and upgrading it as necessary.

• This is for creating db “onCreate(SQLiteDataBase)”.

• when the database needs to be upgraded

“onUpgrade (SQLiteDataBase db, int oldVersion, intnewVersion)”.

• when the database has been opened “onOpen (SQLiteDataBase db)”.

SQLite Database

Public class Activity extends SQLiteOpenHelper{

private static final String KEY_ID = "id";

private static final String KEY_NAME = "name";

public void onCreate(SQLiteDatabase mydb) {

mydb.execSQL("CREATE TABLE IF NOT EXISTS “ +TableName+" (ColumnName DataType);");

}

public void onUpgrade(SQLiteDatabase mydb, int oldVersion, intnewVersion) {

// Drop older table if existed

mydb.execSQL("DROP TABLE IF EXISTS " + TABLE_CONTACTS);

// Create tables again

onCreate(mydb);

} }

Data Storage

• Shared Preferences summary

1.Shared Preferences stores data as key-pairs only.

2.Key is required to read data from it.

3. Reading and storing data in it is very simple.

4. It is difficult to store and read large structured data

5. It saves primitives data type like string, int ,booleans, floats ,long etc

6. It is best to use Shared Preferences when only small amount of data needs to be stored eg few app settings, user login /password etc.

Data Storage

• SQLite Summary

1.It stores structured data as a database.

2.The data can be queried.

3.Reading data from sqlite database is slower and more expensive then shared preferences

4. It can save large data upto 200kb

5.SQLite database is useful for just about anything and very flexible.

6.It is best to use Sqlite when the data to be stored is large , structured and required searching .eg storing complete user details , storing data fetched by http request etc.

Android Data Storage

• Conclusion : Both Preferences and SQLite are having their importance based on the size of the data requirement in android.

ANY QUERIES???