sólo tiene que utilizar:
SQLiteDatabase.openDatabase(DB_FULL_PATH, null, SQLiteDatabase.OPEN_READONLY);
donde DB_FULL_PATH puede ser un camino hacia su sdcard, como /sdcard/mydatabase.db
Editar:
Esto es lo que llamo en mi solicitud de acceder a la base de datos ...
private static DBUtil dbHelper = null;
public void openDatabase() {
if(dbHelper == null) {
dbHelper = new DBUtil(this.context);
dbHelper.openDataBase(SQLiteDatabase.OPEN_READWRITE);
}
}
public void closeDatabase() {
if(dbHelper != null) {
dbHelper.close();
dbHelper = null;
}
}
... y esta es la clase de ayudante de db que estoy usando, que de hecho, se extiende SQLiteOpenHelper, por lo que todavía tendrá todo lo que desea de esta clase.
package com.myapp.android.db;
import android.content.Context;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import com.myapp.android.MyApp;
import java.io.IOException;
/**
* Standard database utility class.
*
* TODO: Refactor.
*/
public class DBUtil extends SQLiteOpenHelper {
/**
* Database directory.
*
* <p>
* Example: "/sdcard/myapp/db/"
* </p>
*/
public static String DB_DIRECTORY = null;
/**
* Name of the database file.
*
* <p>
* Example: "mydatabase.db"
* </p>
*
*/
public static String DB_NAME = null;
/**
* Full absolute path of the database.
*
* <p>
* Example: "/sdcard/myapp/db/mydatabase.db"
* </p>
*/
public static String DB_FULL_PATH = null;
static {
DB_DIRECTORY = MyApp.DATA_REPOSITORY_URI + "/myapp/db/";
DB_NAME = "mydatabase.db";
DB_FULL_PATH = DB_DIRECTORY + DB_NAME;
}
private SQLiteDatabase myDataBase;
/**
* Constructor Takes and keeps a reference of the passed context in order to
* access to the application assets and resources.
*
* @param context
*/
public DBUtil(Context context) {
super(context, DB_NAME, null, 1);
try {
this.createDataBase();
} catch (IOException ioe) {
throw new Error("Unable to create database");
}
}
/**
* Creates a empty database on the system and rewrites it with your own
* database.
* */
public void createDataBase() throws IOException {
if (!checkDataBase()) this.getWritableDatabase();
}
/**
* Check if the database already exist to avoid re-copying the file each
* time you open the application.
*
* @return true if it exists, false if it doesn't
*/
private boolean checkDataBase() {
SQLiteDatabase checkDB = null;
try {
checkDB = SQLiteDatabase.openDatabase(DB_FULL_PATH, null,
SQLiteDatabase.OPEN_READONLY);
} catch (SQLiteException e) {
// database does't exist yet.
}
if (checkDB != null) {
checkDB.close();
}
return checkDB != null ? true : false;
}
public void openDataBase(int mode) throws SQLException {
try {
myDataBase = SQLiteDatabase.openDatabase(DB_FULL_PATH, null, mode);
} catch(IllegalStateException e) {
// Sometimes, esp. after application upgrade, the database will be non-closed, raising a IllegalStateException
// below. Try to avoid by simply opening it again.
Log.d(MyApp.APP, "Database non-closed. Reopening.");
myDataBase = SQLiteDatabase.openDatabase(DB_FULL_PATH, null, mode);
}
}
public void openDataBase() throws SQLException {
openDataBase(SQLiteDatabase.OPEN_READWRITE);
}
public SQLiteDatabase getDb() {
return myDataBase;
}
@Override
public synchronized void close() {
if (myDataBase != null)
myDataBase.close();
super.close();
}
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}
No estoy seguro de que esto se puede utilizar junto con SQLiteOpenHelper. Lamentablemente, no estoy en mi área de trabajo ahora mismo y no puedo probar. Sin embargo, votará si es tan simple como eso. – GJTorikian
¿Se pregunta por qué necesita explícitamente SQLiteOpenHelper? –
Tiene un montón de métodos de ayuda para la creación de bases de datos y actualizaciones de bases de datos. No estoy familiarizado con una forma más simple de manejar esas acciones. – GJTorikian