android 初始化类,如何从Android中的助手类初始化sqlite数据库...

我有一个自定义的DataBaseHelper类,它扩展了SQLiteOpenHelper,如下所示：

package com.stampii.stampii.comm.rpc;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.sql.ResultSet;

import android.content.ContentValues;

import android.content.Context;

import android.database.Cursor;

import android.database.sqlite.SQLiteDatabase;

import android.database.sqlite.SQLiteDatabase.CursorFactory;

import android.database.sqlite.SQLiteException;

import android.database.sqlite.SQLiteOpenHelper;

import android.util.Log;

public class DataBaseHelper extends SQLiteOpenHelper{

private static SQLiteDatabase sqliteDb;

private static DataBaseHelper instance;

private static final int DATABASE_VERSION = 1;

// the default database path is :

// /data/data/pkgNameOfYourApplication/databases/

private static String DB_PATH_PREFIX = "/data/data/";

private static String DB_PATH_SUFFIX = "/databases/";

private static final String TAG = "DataBaseHelper";

private Context context;

/***

* Contructor

*

* @param context

* : app context

* @param name

* : database name

* @param factory

* : cursor Factory

* @param version

* : DB version

*/

public DataBaseHelper(Context context, String name,

CursorFactory factory, int version) {

super(context, name, factory, version);

this.context = context;

Log.i(TAG, "Create or Open database : " + name);

}

/***

* Initialize method

*

* @param context

* : application context

* @param databaseName

* : database name

*/

public static void initialize(Context context, String databaseName) {

if (instance == null) {

/**

* Try to check if there is an Original copy of DB in asset

* Directory

*/

if (!checkDatabase(context, databaseName)) {

// if not exists, I try to copy from asset dir

try {

copyDataBase(context, databaseName);

} catch (IOException e) {

Log.e(TAG,"Database "+ databaseName+" does not exists and there is no Original Version in Asset dir");

}

}

Log.i(TAG, "Try to create instance of database (" + databaseName

+ ")");

instance = new DataBaseHelper(context, databaseName,

null, DATABASE_VERSION);

sqliteDb = instance.getWritableDatabase();

Log.i(TAG, "instance of database (" + databaseName + ") created !");

}

}

/***

* Static method for getting singleton instance

*

* @param context

* : application context

* @param databaseName

* : database name

* @return : singleton instance

*/

public static final DataBaseHelper getInstance(

Context context, String databaseName) {

initialize(context, databaseName);

return instance;

}

/***

* Method to get database instance

*

* @return database instance

*/

public SQLiteDatabase getDatabase() {

return sqliteDb;

}

@Override

public void onCreate(SQLiteDatabase db) {

Log.d(TAG, "onCreate : nothing to do");

}

@Override

public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

Log.d(TAG, "onUpgrade : nothing to do");

}

/***

* Method for Copy the database from asset directory to application's data

* directory

*

* @param databaseName

* : database name

* @throws IOException

* : exception if file does not exists

*/

public void copyDataBase(String databaseName) throws IOException {

copyDataBase(context, databaseName);

}

/***

* Static method for copy the database from asset directory to application's

* data directory

*

* @param aContext

* : application context

* @param databaseName

* : database name

* @throws IOException

* : exception if file does not exists

*/

private static void copyDataBase(Context aContext, String databaseName)

throws IOException {

// Open your local db as the input stream

InputStream myInput = aContext.getAssets().open(databaseName);

// Path to the just created empty db

String outFileName = getDatabasePath(aContext, databaseName);

Log.i(TAG, "Check if create dir : " + DB_PATH_PREFIX

+ aContext.getPackageName() + DB_PATH_SUFFIX);

// if the path doesn't exist first, create it

File f = new File(DB_PATH_PREFIX + aContext.getPackageName()

+ DB_PATH_SUFFIX);

if (!f.exists())

f.mkdir();

Log.i(TAG, "Trying to copy local DB to : " + outFileName);

// Open the empty db as the output stream

OutputStream myOutput = new FileOutputStream(outFileName);

// transfer bytes from the inputfile to the outputfile

byte[] buffer = new byte[1024];

int length;

while ((length = myInput.read(buffer)) > 0) {

myOutput.write(buffer, 0, length);

}

// Close the streams

myOutput.flush();

myOutput.close();

myInput.close();

Log.i(TAG, "DB (" + databaseName + ") copied!");

}

/***

* Method to check if database exists in application's data directory

*

* @param databaseName

* : database name

* @return : boolean (true if exists)

*/

public boolean checkDatabase(String databaseName) {

return checkDatabase(context, databaseName);

}

/***

* Static Method to check if database exists in application's data directory

*

* @param aContext

* : application context

* @param databaseName

* : database name

* @return : boolean (true if exists)

*/

private static boolean checkDatabase(Context aContext, String databaseName) {

SQLiteDatabase checkDB = null;

try {

String myPath = getDatabasePath(aContext, databaseName);

Log.i(TAG, "Trying to conntect to : " + myPath);

checkDB = SQLiteDatabase.openDatabase(myPath, null,

SQLiteDatabase.OPEN_READONLY);

Log.i(TAG, "Database " + databaseName + " found!");

checkDB.close();

} catch (SQLiteException e) {

Log.i(TAG, "Database " + databaseName + " does not exists!");

}

return checkDB != null ? true : false;

}

/***

* Method that returns database path in the application's data directory

*

* @param databaseName

* : database name

* @return : complete path

*/

private String getDatabasePath(final String databaseName) {

return getDatabasePath(context, databaseName);

}

/***

* Static Method that returns database path in the application's data

* directory

*

* @param aContext

* : application context

* @param databaseName

* : database name

* @return : complete path

*/

private static String getDatabasePath(Context aContext, String databaseName) {

return DB_PATH_PREFIX + aContext.getPackageName() + DB_PATH_SUFFIX

+ databaseName;

}

public boolean executeQuery(String tableName,String keys,String value){

return execQuery(tableName,keys,value);

}

private static boolean execQuery(String tableName,String key,String value){

sqliteDb = instance.getWritableDatabase();

ContentValues values = new ContentValues();

values.put(key, value);

sqliteDb.insert(tableName, null, values);

return true;

}

public boolean updateSQL(String tableName,String key,String value){

return updateData(tableName,key,value);

}

private static boolean updateData(String tableName,String key,String value){

sqliteDb = instance.getWritableDatabase();

String where = "code_id=?";

ContentValues values = new ContentValues();

values.put(key, value);

values.put(key, value);

sqliteDb.update(tableName, values, where, new String[] {"3"});

return true;

}

public boolean deleteSQL(String tableName){

return deleteData(tableName);

}

private static boolean deleteData(String tableName){

sqliteDb = instance.getWritableDatabase();

String where = "code_id=?";

sqliteDb.delete(tableName, where, new String[] {"5"});

return true;

}

public Cursor executeSQLQuery(String query){

return sqliteDb.rawQuery(query,null);

}

}

我的问题是：如何只初始化数据库一次,并可以从我的所有活动中访问它？ (提示：我的资产文件夹中有sqlite文件,当应用程序出星时,我将其复制到我的系统数据库文件夹中.)

提前致谢！

编辑：我忘了说我的应用程序中有两个不同的sqlite数据库,我希望能够为整个应用程序初始化它们并可以使用它们.这是我试图做的事情：

DataBaseHelper dbHelper;

//some code

dbHelper = new DataBaseHelper(context, "ops_sys_tpl.sqlite", null, 1);

DataBaseHelper.initialize(context, "stampii_sys_tpl.sqlite");

dbHelper.copyDataBase("ops_sys_tpl.sqlite");

dbHelper.getDatabase();

dbHelper.executeQuery("users", "objectId", "2");

dbHelper.executeQuery("users","serverName","stampii");

dbHelper.executeQuery("users", "objectId", "3");

dbHelper.executeQuery("users","serverName","stampii");

dbHelper.executeQuery("users", "objectId", "3");