Android UI(3)Getting Started - Saving Data - android

Android UI(3)Getting Started - Saving Data

1. Saving Data
Saving Key-Value Sets
SharedPreferences object points to a file containing key-value pairs and provides simple methods to read and write them.

Get a Handle to a SharedPreferences
getSharedPreferences(key_name,mode) - Multiple shared preference files identified by names, and this is called by Context.

In activity:
Context context = getActivity();
SharedPreferences sharedPref = context.getSharedPreferences(getString(R.string.preference_file_key), Context.MODE_PRIVATE);

getPreferences() - Only one shared preference file for the activity.

SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);

If we create preferences file with MODE_WORLD_READABLE or MODE_WORLD_WRITEABLE, then other apps can access the data.

Write to Shared Preferences
SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
editor.putInt(getString(R.string.saved_high_score), newHighScore); // getString()
editor.commit();

Read from Shared Preferences
SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
int defaultValue = getResources().getInteger(R.string.saved_high_score_default);

long highScore = sharedPref.getInt(getString(R.string.saved_high_score), defaultValue);

2. Saving Files
Deal with the android file system with the File API. It is good the store the image files or anything exchanged over a network.

Choose Internal or External Storage
“internal” and "external" storage are coming from the old days, when most devices offered built-in non-volatile memory(internal storage), removable storage medium such as a micro SD card(external storage).

The apps are installed onto the internal storage by default, you can specify the android:installLocation in manifest file.

Obtain Permissions for External Storage
<manifest …>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
</manifest>

Right now, apps have the read permission by default to external storage.

And for internal storage, by default, apps have that permissions.

Save a File on Internal Storage
File handler methods:
getFileDir()

getCacheDir()

File file = new File(context.getFilesDir(), filename);

Examples to write a file>
String filename = "myfile";
String hello = "Hello";
FileOutputStream outputStream;
try{
outputStream = openFileOutput(filename, Context.MODE_PRIVATE);
outputStream.write(hello.getBytes());
}catch(Exception e){
e.printStackTrace();
}finally{
outputStream.close();
}

Save a File on External Storage
public boolean isExternalStorageWritable(){
String state = Environment.getExternalStorageState();
if(Evironment.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;
}

Even all the files stored on external storage can be accessed by other apps. But there are still 2 parts in external, private and public.

public File getAlbumStorageDir(String albumName){
File file = new File(Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES),albumName);
if(!file.mkdirs()){
Log.e(LOG_TAG, "Directory not there");
}
return file;
}

public File getAlbumStorageDir(Context context, String albumName){
File file = new File(context.getExternalFilesDir(
Environment.DIRECTORY_PICTURES), albumName);
if(!file.mkdirs()){
Log.e(LOG_TAG, "Directory not there!");
}
return file;
}

Query Free Space
getFreeSpace()
getTotalSpace()

Delete a File
myFile.delete()

myContext.deleteFile(fileName);

3. Saving Data in SQL Databases
android.database.sqlite

Define a Schema and Contract
//===========database
public static final String TABLE_NAME = "product";
public static final String COLUMN_NAME_PRODUCT_ID = "product_id";
public static final String COLUMN_NAME_PRODUCT_NAME = "product_name";
public static final String COLUMN_NAME_PRODUCT_PRICE = "product_price";
public static final String COLUMN_NAME_PRODUCT_DESN = "product_desn";
public static final String COLUMN_NAME_PRODUCT_IMAGE_URL = "product_imageurl";

publicstaticfinalStringSQL_CREATE = "CREATE TABLE " + TABLE_NAME + " ( " +
COLUMN_NAME_PRODUCT_ID + " INTEGER PRIMARY KEY," +
COLUMN_NAME_PRODUCT_NAME + " TEXT," +
COLUMN_NAME_PRODUCT_PRICE + " TEXT," +
COLUMN_NAME_PRODUCT_DESN + " TEXT," +
COLUMN_NAME_PRODUCT_IMAGE_URL + " TEXT" +
");";
public static final String SQL_DROP = "DROP TABLE IF EXISTS " + TABLE_NAME;
//===========database

I defined all these things in my model object.

Create a Database Using a SQL Helper
package com.sillycat.easyrestclientandroid.dao.db;

import com.sillycat.easyrestclientandroid.model.Product;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class BasicDBHelper extends SQLiteOpenHelper {

public static final int DATABASE_VERSION = 1;

public static final String DATABASE_NAME = "sillycat.db";

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

public void onCreate(SQLiteDatabase db) {
db.execSQL(Product.SQL_CREATE);
}

public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL(Product.SQL_DROP);
onCreate(db);
}

}

Put Information into a Database
public class ProductDBDAOImpl implements ProductDAO {
private BasicDBHelper helper;
public ProductDBDAOImpl(BasicDBHelper helper) {
this.helper = helper;
}
…snip…
public Product insert(Product product) {
synchronized (DBGuard.class) {
SQLiteDatabase db = null;
try {
db = helper.getWritableDatabase();
Long id = db.insert(Product.TABLE_NAME,
Product.COLUMN_NAME_PRODUCT_NAME, getValues(product));
product.setProductId(id);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (db != null) {
db.close();
}
}
return product;
}
}

private ContentValues getValues(Product item) {
ContentValues values = new ContentValues();
values.put(Product.COLUMN_NAME_PRODUCT_DESN, item.getProductDesn());
values.put(Product.COLUMN_NAME_PRODUCT_ID, item.getProductId());
values.put(Product.COLUMN_NAME_PRODUCT_IMAGE_URL,item.getProductImageURL());
values.put(Product.COLUMN_NAME_PRODUCT_NAME, item.getProductName());
values.put(Product.COLUMN_NAME_PRODUCT_PRICE, item.getProductPrice());
return values;
}

…snip…
}

Read Information from a Database
public List<Product> all() {
List<Product> items = new ArrayList<Product>();
synchronized (DBGuard.class) {
SQLiteDatabase db = null;
Cursor cursor = null;
try {
db = helper.getReadableDatabase();
cursor = db.query(Product.TABLE_NAME, new String[] {
Product.COLUMN_NAME_PRODUCT_DESN,
Product.COLUMN_NAME_PRODUCT_ID,
Product.COLUMN_NAME_PRODUCT_IMAGE_URL,
Product.COLUMN_NAME_PRODUCT_NAME,
Product.COLUMN_NAME_PRODUCT_PRICE }, null, null, null, null, null);
if (cursor != null && cursor.getColumnCount() > 0) {
cursor.moveToFirst();
while (cursor.getPosition() != cursor.getCount()) {
items.add(getItem(cursor));
cursor.moveToNext();
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (cursor != null) {
cursor.close();
}
if (db != null) {
db.close();
}
}
}
return items;
}

private Product getItem(Cursor cursor) {
Product item = new Product();
item.setProductDesn(cursor.getString(0));
item.setProductId(cursor.getLong(1));
item.setProductImageURL(cursor.getString(2));
item.setProductName(cursor.getString(3));
item.setProductPrice(cursor.getString(4));
return item;
}

Delete Information from a Database
publicboolean deleteById(Long productId) {
synchronized (DBGuard.class) {
SQLiteDatabase db = null;
try {
db = helper.getReadableDatabase();
db.delete(Product.TABLE_NAME, "id = ?",
new String[] { productId + "" });
} catch (Exception e) {
e.printStackTrace();
} finally {
if (db != null) {
db.close();
}
}
}
return false;
}

Update a Database
public Product update(Product product) {
Product item = null;
synchronized (DBGuard.class) {
SQLiteDatabase db = null;
try {
db = helper.getWritableDatabase();
db.update(Product.TABLE_NAME, getValues(product), "id=?",
new String[] { "" + product.getProductId() });
} catch (Exception e) {
e.printStackTrace();
} finally {
if (db != null) {
db.close();
}
}
}
return item;
}

DBGuard is just an empty class that used to lock the synchronized things. I am not sure it is necessary. How can the customer type his mobile devices in that fast? Haha.

References:
http://developer.android.com/training/basics/data-storage/index.html

Android UI(3)Getting Started - Saving Data

更多相关文章

随机推荐