理解 Android 本地数据存储 API

MainActivity

Friend

AppPreferenceActivity

DBHelper

{

"data": [

{

"name": "Edmund Troche",

"id": "500067699"

}

]

}

package com.cenriqueortiz.tutorials.datastore;

import android.graphics.Bitmap;

/**

* Represents a Friend

*/

public class Friend {

public String id;

public String name;

public byte[] picture;

public Bitmap pictureBitmap;;

}

db.execSQL("create table " + TABLE_NAME + " (_id integer primary key autoincrement, "

+ " fid text not null, name text not null) ");

<?xml version="1.0" encoding="utf-8"?>

<PreferenceScreen

xmlns:android="http://schemas.android.com/apk/res/android"

android:id="@+id/prefs_screen"

android:key="preferencescreen"

>

<PreferenceCategory android:title="Assets">

<EditTextPreference

android:key="@string/prefs_assetname_friendslist_key"

android:title="Friends List"

android:summary="Please enter filename"

android:defaultValue="friends.txt"

/>

<EditTextPreference

android:key="@string/prefs_assetname_picture_key"

android:title="Picture"

android:summary="Please enter filename"

android:defaultValue="pict2.jpg"

/>

</PreferenceCategory>

<PreferenceCategory android:title="Auto Settings">

<CheckBoxPreference

android:key="@string/prefs_autodelete_key"

android:title="Delete at Startup"

android:summary="Check to clear at startup"

android:defaultValue="false"

/>

</PreferenceCategory>

</PreferenceScreen>

/*

* AppPreferenceActivity is a basic PreferenceActivity

* C. Enrique Ortiz | http://CEnriqueOrtiz.com 
*/

package com.cenriqueortiz.tutorials.datastore;

import android.os.Bundle;

import android.preference.PreferenceActivity;

public class AppPreferenceActivity extends PreferenceActivity {

/**

* Default Constructor

*/

public AppPreferenceActivity() {}

/**

* Called when the activity is first created.

*   Inflate the Preferences Screen XML declaration.

*/

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

addPreferencesFromResource(R.xml.prefs); // Inflate the XML declaration

}

}

/**

* Invoked when a menu item has been selected

*/

@Override

public boolean onOptionsItemSelected(MenuItem item) {

switch (item.getItemId()) {

// Case: Bring up the Preferences Screen

case R.id.menu_prefs: // Preferences

// Launch the Preference Activity

Intent i = new Intent(this, AppPreferenceActivity.class);

startActivity(i);

break;

case R.id.menu...:

:

break;

}

return true;

}

:

<application android:icon="@drawable/icon" android:label="@string/app_name">

:

:

<activity

android:name="AppPreferenceActivity"

android:label="Preferences">

</activity>

:

</application>

/////////////////////////////////////////////////////////////

// The following methods show how to use the SharedPreferences

/////////////////////////////////////////////////////////////

/**

* Retrieves the Auto delete preference

* @return the value of auto delete

*/

public boolean prefsGetAutoDelete() {

boolean v = false;

SharedPreferences sprefs =

PreferenceManager.getDefaultSharedPreferences(appContext);

String key = appContext.getString(R.string.prefs_autodelete_key);

try {

v = sprefs.getBoolean(key, false);

} catch (ClassCastException e) {

}

return v;

}

/**

* Sets the auto delete preference

* @param v the value to set

*/

public void  prefsSetAutoDelete(boolean v) {

SharedPreferences sprefs =

PreferenceManager.getDefaultSharedPreferences(appContext);

Editor e = sprefs.edit();

String key = appContext.getString(R.string.prefs_autodelete_key);

e.putBoolean(key, v);

e.commit();

}

package com.cenriqueortiz.tutorials.datastore;

import java.util.ArrayList;

import android.content.Context;

import android.database.Cursor;

import android.database.sqlite.SQLiteDatabase;

import android.database.sqlite.SQLiteOpenHelper;

public class DBHelper extends SQLiteOpenHelper {

private SQLiteDatabase db;

private static final int DATABASE_VERSION = 1;

private static final String DB_NAME = "sample.db";

private static final String TABLE_NAME = "friends";

/**

* Constructor

* @param context the application context

*/

public DBHelper(Context context) {

super(context, DB_NAME, null, DATABASE_VERSION);

db = getWritableDatabase();

}

/**

* Called at the time to create the DB.

* The create DB statement

* @param the SQLite DB

*/

@Override

public void onCreate(SQLiteDatabase db) {

db.execSQL(

"create table " + TABLE_NAME + " (_id integer primary key autoincrement,

" + " fid text not null, name text not null) ");

}

/**

* The Insert DB statement

* @param id the friends id to insert

* @param name the friend's name to insert

*/

public void insert(String id, String name) {

db.execSQL("INSERT INTO friends('fid', 'name') values ('"

+ id + "', '"

+ name + "')");

}

/**

* Wipe out the DB

*/

public void clearAll() {

db.delete(TABLE_NAME, null, null);

}

/**

* Select All returns a cursor

* @return the cursor for the DB selection

*/

public Cursor cursorSelectAll() {

Cursor cursor = this.db.query(

TABLE_NAME, // Table Name

new String[] { "fid", "name" }, // Columns to return

null,       // SQL WHERE

null,       // Selection Args

null,       // SQL GROUP BY

null,       // SQL HAVING

"name");    // SQL ORDER BY

return cursor;

}

/**

* Select All that returns an ArrayList

* @return the ArrayList for the DB selection

*/

public ArrayList<Friend> listSelectAll() {

ArrayList<Friend> list = new ArrayList<Friend>();

Cursor cursor = this.db.query(TABLE_NAME, new String[] { "fid", "name" },

null, null, null, null, "name");

if (cursor.moveToFirst()) {

do {

Friend f = new Friend();

f.id = cursor.getString(0);

f.name = cursor.getString(1);

list.add(f);

} while (cursor.moveToNext());

}

if (cursor != null && !cursor.isClosed()) {

cursor.close();

}

return list;

}

/**

* Invoked if a DB upgrade (version change) has been detected

*/

@Override

/**

* Invoked if a DB upgrade (version change) has been detected

*/

@Override

public void onUpgrade(SQLiteDatabase db,

int oldVersion, int newVersion) {

// Here add any steps needed due to version upgrade

// for example, data format conversions, old tables

// no longer needed, etc

}

}

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

appContext = this;

setContentView(R.layout.main);

dbHelper = new DBHelper(this);

listView = (ListView) findViewById(R.id.friendsview);

friendsArrayAdapter = new FriendsArrayAdapter(

this, R.layout.rowlayout, friends);

listView.setAdapter(friendsArrayAdapter);

:

:

}

String fname = prefsGetFilename();

if (fname != null && fname.length() > 0) {

buffer = getAsset(fname);

// Parse the JSON file

String friendslist = new String(buffer);

final JSONObject json = new JSONObject(friendslist);

JSONArray d = json.getJSONArray("data");

int l = d.length();

for (int i2=0; i2<l; i2++) {

JSONObject o = d.getJSONObject(i2);

String n = o.getString("name");

String id = o.getString("id");

dbHelper.insert(id, n);

}

// Only the original owner thread can touch its views

MainActivity.this.runOnUiThread(new Runnable() {

public void run() {

friendsArrayAdapter.notifyDataSetChanged();

}

});

}

final ArrayList<Friend> dbFriends = dbHelper.listSelectAll();

if (dbFriends != null) {

// Only the original owner thread can touch its views

MainActivity.this.runOnUiThread(new Runnable() {

public void run() {

friendsArrayAdapter =

new FriendsArrayAdapter(

MainActivity.this, R.layout.rowlayout, dbFriends);

listView.setAdapter(friendsArrayAdapter);

friendsArrayAdapter.notifyDataSetChanged();

}

});

}

/**

* Writes content to internal storage making the content private to

* the application. The method can be easily changed to take the MODE

* as argument and let the caller dictate the visibility:

* MODE_PRIVATE, MODE_WORLD_WRITEABLE, MODE_WORLD_READABLE, etc.

*

* @param filename - the name of the file to create

* @param content - the content to write

*/

public void writeInternalStoragePrivate(

String filename, byte[] content) {

try {

//MODE_PRIVATE creates/replaces a file and makes

//  it private to your application. Other modes:

//    MODE_WORLD_WRITEABLE

//    MODE_WORLD_READABLE

//    MODE_APPEND

FileOutputStream fos =

openFileOutput(filename, Context.MODE_PRIVATE);

fos.write(content);

fos.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

/**

* Reads a file from internal storage

* @param filename the file to read from

* @return the file content

*/

public byte[] readInternalStoragePrivate(String filename) {

int len = 1024;

byte[] buffer = new byte[len];

try {

FileInputStream fis = openFileInput(filename);

ByteArrayOutputStream baos = new ByteArrayOutputStream();

int nrb = fis.read(buffer, 0, len); // read up to len bytes

while (nrb != -1) {

baos.write(buffer, 0, nrb);

nrb = fis.read(buffer, 0, len);

}

buffer = baos.toByteArray();

fis.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

return buffer;

}

/**

* Delete internal private file

* @param filename - the filename to delete

*/

public void deleteInternalStoragePrivate(String filename) {

File file = getFileStreamPath(filename);

if (file != null) {

file.delete();

}

}

/**

* Helper Method to Test if external Storage is Available

*/

public boolean isExternalStorageAvailable() {

boolean state = false;

String extStorageState = Environment.getExternalStorageState();

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

state = true;

}

return state;

}

/**

* Helper Method to Test if external Storage is read only

*/

public boolean isExternalStorageReadOnly() {

boolean state = false;

String extStorageState = Environment.getExternalStorageState();

if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(extStorageState)) {

state = true;

}

return state;

}

/**

* Write to external public directory

* @param filename - the filename to write to

* @param content - the content to write

*/

public void writeToExternalStoragePublic(String filename, byte[] content) {

// API Level 7 or lower, use getExternalStorageDirectory()

//  to open a File that represents the root of the external

// storage, but writing to root is not recommended, and instead

// application should write to application-specific directory, as shown below.

String packageName = this.getPackageName();

String path = "/Android/data/" + packageName + "/files/";

if (isExternalStorageAvailable() &&

!isExternalStorageReadOnly()) {

try {

File file = new File(path, filename);

file.mkdirs();

FileOutputStream fos = new FileOutputStream(file);

fos.write(content);

fos.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

/**

* Reads a file from internal storage

* @param filename - the filename to read from

* @return the file contents

*/

public byte[] readExternallStoragePublic(String filename) {

int len = 1024;

byte[] buffer = new byte[len];

String packageName = this.getPackageName();

String path = "/Android/data/" + packageName + "/files/";

if (!isExternalStorageReadOnly()) {

try {

File file = new File(path, filename);

FileInputStream fis = new FileInputStream(file);

ByteArrayOutputStream baos = new ByteArrayOutputStream();

int nrb = fis.read(buffer, 0, len); //read up to len bytes

while (nrb != -1) {

baos.write(buffer, 0, nrb);

nrb = fis.read(buffer, 0, len);

}

buffer = baos.toByteArray();

fis.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

return buffer;

}

/**

* Delete external public file

* @param filename - the filename to write to

*/

void deleteExternalStoragePublicFile(String filename) {

String packageName = this.getPackageName();

String path = "/Android/data/" + packageName + "/files/"+filename;

File file = new File(path, filename);

if (file != null) {

file.delete();

}

}

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

/**

* Helper method to retrieve the absolute path to the application

* specific internal cache directory on the file system. These files

* will be ones that get deleted when the application is uninstalled or when

* the device runs low on storage. There is no guarantee when these

* files will be deleted.

*

* Note: This uses a Level 8+ API.

*

* @return the absolute path to the application specific cache

* directory

*/

public String getInternalCacheDirectory() {

String cacheDirPath = null;

File cacheDir = getCacheDir();

if (cacheDir != null) {

cacheDirPath = cacheDir.getPath();

}

return cacheDirPath;

}

/**

* Helper method to retrieve the absolute path to the application

* specific external cache directory on the file system. These files

* will be ones that get deleted when the application is uninstalled or when

* the device runs low on storage. There is no guarantee when these

* files will be deleted.

*

* Note: This uses a Level 8+ API.

*

* @return the absolute path to the application specific cache

* directory

*/

public String getExternalCacheDirectory() {

String extCacheDirPath = null;

File cacheDir = getExternalCacheDir();

if (cacheDir != null) {

extCacheDirPath = cacheDir.getPath();

}

return extCacheDirPath;

}