so i have a existing database in sqlite which i need to read, but is giving me issues and i dont know what to do
public class SQLiteAssetHelper extends SQLiteOpenHelper {
private static final String TAG = SQLiteAssetHelper.class.getSimpleName();
private static final String ASSET_DB_PATH = "databases";
private final Context mContext;
private final String mName;
private final CursorFactory mFactory;
private final int mNewVersion;
private SQLiteDatabase mDatabase = null;
private boolean mIsInitializing = false;
private String mDatabasePath;
private String mAssetPath;
private String mUpgradePathFormat;
private int mForcedUpgradeVersion = 0;
public SQLiteAssetHelper(Context context, String name, String storageDirectory, CursorFactory factory, int version) {
super(context, name, factory, version);
if (version < 1) throw new IllegalArgumentException("Version must be >= 1, was " + version);
if (name == null) throw new IllegalArgumentException("Database name cannot be null");
mContext = context;
mName = name;
mFactory = factory;
mNewVersion = version;
mAssetPath = ASSET_DB_PATH + "/" + name;
if (storageDirectory != null) {
mDatabasePath = storageDirectory;
} else {
mDatabasePath = context.getApplicationInfo().dataDir + "/databases";
}
mUpgradePathFormat = ASSET_DB_PATH + "/" + name + "_upgrade_%s-%s.sql";
}
public SQLiteAssetHelper(Context context, String name, CursorFactory factory, int version) {
this(context, name, null, factory, version);
}
@Override
public synchronized SQLiteDatabase getWritableDatabase() {
if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {
return mDatabase; // The database is already open for business
}
if (mIsInitializing) {
throw new IllegalStateException("getWritableDatabase called recursively");
}
boolean success = false;
SQLiteDatabase db = null;
//if (mDatabase != null) mDatabase.lock();
try {
mIsInitializing = true;
//if (mName == null) {
// db = SQLiteDatabase.create(null);
//} else {
// db = mContext.openOrCreateDatabase(mName, 0, mFactory);
//}
db = createOrOpenDatabase(false);
int version = db.getVersion();
// do force upgrade
if (version != 0 && version < mForcedUpgradeVersion) {
db = createOrOpenDatabase(true);
db.setVersion(mNewVersion);
version = db.getVersion();
}
if (version != mNewVersion) {
db.beginTransaction();
try {
if (version == 0) {
onCreate(db);
} else {
if (version > mNewVersion) {
Log.w(TAG, "Can't downgrade read-only database from version " +
version + " to " + mNewVersion + ": " + db.getPath());
}
onUpgrade(db, version, mNewVersion);
}
db.setVersion(mNewVersion);
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
}
onOpen(db);
success = true;
return db;
} finally {
mIsInitializing = false;
if (success) {
if (mDatabase != null) {
try { mDatabase.close(); } catch (Exception e) { }
//mDatabase.unlock();
}
mDatabase = db;
} else {
//if (mDatabase != null) mDatabase.unlock();
if (db != null) db.close();
}
}
}
@Override
public synchronized SQLiteDatabase getReadableDatabase() {
if (mDatabase != null && mDatabase.isOpen()) {
return mDatabase; // The database is already open for business
}
if (mIsInitializing) {
throw new IllegalStateException("getReadableDatabase called recursively");
}
try {
return getWritableDatabase();
} catch (SQLiteException e) {
if (mName == null) throw e; // Can't open a temp database read-only!
Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e);
}
SQLiteDatabase db = null;
try {
mIsInitializing = true;
String path = mContext.getDatabasePath(mName).getPath();
db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);
if (db.getVersion() != mNewVersion) {
throw new SQLiteException("Can't upgrade read-only database from version " +
db.getVersion() + " to " + mNewVersion + ": " + path);
}
onOpen(db);
Log.w(TAG, "Opened " + mName + " in read-only mode");
mDatabase = db;
return mDatabase;
} finally {
mIsInitializing = false;
if (db != null && db != mDatabase) db.close();
}
}
/**
* Close any open database object.
*/
@Override
public synchronized void close() {
if (mIsInitializing) throw new IllegalStateException("Closed during initialization");
if (mDatabase != null && mDatabase.isOpen()) {
mDatabase.close();
mDatabase = null;
}
}
@Override
public final void onConfigure(SQLiteDatabase db) {
// not supported!
}
@Override
public final void onCreate(SQLiteDatabase db) {
// do nothing - createOrOpenDatabase() is called in
// getWritableDatabase() to handle database creation.
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(TAG, "Upgrading database " + mName + " from version " + oldVersion + " to " + newVersion + "...");
ArrayList<String> paths = new ArrayList<String>();
getUpgradeFilePaths(oldVersion, newVersion-1, newVersion, paths);
if (paths.isEmpty()) {
Log.e(TAG, "no upgrade script path from " + oldVersion + " to " + newVersion);
throw new SQLiteAssetException("no upgrade script path from " + oldVersion + " to " + newVersion);
}
Collections.sort(paths, new VersionComparator());
for (String path : paths) {
try {
Log.w(TAG, "processing upgrade: " + path);
InputStream is = mContext.getAssets().open(path);
String sql = Utils.convertStreamToString(is);
if (sql != null) {
List<String> cmds = Utils.splitSqlScript(sql, ';');
for (String cmd : cmds) {
//Log.d(TAG, "cmd=" + cmd);
if (cmd.trim().length() > 0) {
db.execSQL(cmd);
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
Log.w(TAG, "Successfully upgraded database " + mName + " from version " + oldVersion + " to " + newVersion);
}
@Override
public final void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// not supported!
}
@Deprecated
public void setForcedUpgradeVersion(int version) {
setForcedUpgrade(version);
}
public void setForcedUpgrade(int version) {
mForcedUpgradeVersion = version;
}
public void setForcedUpgrade() {
setForcedUpgrade(mNewVersion);
}
private SQLiteDatabase createOrOpenDatabase(boolean force) throws SQLiteAssetException {
// test for the existence of the db file first and don't attempt open
// to prevent the error trace in log on API 14+
SQLiteDatabase db = null;
File file = new File (mDatabasePath + "/" + mName);
if (file.exists()) {
db = returnDatabase();
}
//SQLiteDatabase db = returnDatabase();
if (db != null) {
// database already exists
if (force) {
Log.w(TAG, "forcing database upgrade!");
copyDatabaseFromAssets();
db = returnDatabase();
}
return db;
} else {
// database does not exist, copy it from assets and return it
copyDatabaseFromAssets();
db = returnDatabase();
return db;
}
}
private SQLiteDatabase returnDatabase(){
try {
SQLiteDatabase db = SQLiteDatabase.openDatabase(mDatabasePath + "/" + mName, mFactory, SQLiteDatabase.OPEN_READWRITE);
Log.i(TAG, "successfully opened database " + mName);
return db;
} catch (SQLiteException e) {
Log.w(TAG, "could not open database " + mName + " - " + e.getMessage());
return null;
}
}
private void copyDatabaseFromAssets() throws SQLiteAssetException {
Log.w(TAG, "copying database from assets...");
String path = mAssetPath;
String dest = mDatabasePath + "/" + mName;
InputStream is;
boolean isZip = false;
try {
// try uncompressed
is = mContext.getAssets().open(path);
} catch (IOException e) {
// try zip
try {
is = mContext.getAssets().open(path + ".zip");
isZip = true;
} catch (IOException e2) {
// try gzip
try {
is = mContext.getAssets().open(path + ".gz");
} catch (IOException e3) {
SQLiteAssetException se = new SQLiteAssetException("Missing " + mAssetPath + " file (or .zip, .gz archive) in assets, or target folder not writable");
se.setStackTrace(e3.getStackTrace());
throw se;
}
}
}
try {
File f = new File(mDatabasePath + "/");
if (!f.exists()) { f.mkdir(); }
if (isZip) {
ZipInputStream zis = Utils.getFileFromZip(is);
if (zis == null) {
throw new SQLiteAssetException("Archive is missing a SQLite database file");
}
Utils.writeExtractedFileToDisk(zis, new FileOutputStream(dest));
} else {
Utils.writeExtractedFileToDisk(is, new FileOutputStream(dest));
}
Log.w(TAG, "database copy complete");
} catch (IOException e) {
SQLiteAssetException se = new SQLiteAssetException("Unable to write " + dest + " to data directory");
se.setStackTrace(e.getStackTrace());
throw se;
}
}
private InputStream getUpgradeSQLStream(int oldVersion, int newVersion) {
String path = String.format(mUpgradePathFormat, oldVersion, newVersion);
try {
return mContext.getAssets().open(path);
} catch (IOException e) {
Log.w(TAG, "missing database upgrade script: " + path);
return null;
}
}
private void getUpgradeFilePaths(int baseVersion, int start, int end, ArrayList<String> paths) {
int a;
int b;
InputStream is = getUpgradeSQLStream(start, end);
if (is != null) {
String path = String.format(mUpgradePathFormat, start, end);
paths.add(path);
//Log.d(TAG, "found script: " + path);
a = start - 1;
b = start;
is = null;
} else {
a = start - 1;
b = end;
}
if (a < baseVersion) {
return;
} else {
getUpgradeFilePaths(baseVersion, a, b, paths); // recursive call
}
}
/**
* An exception that indicates there was an error with SQLite asset retrieval or parsing.
*/
@SuppressWarnings("serial")
public static class SQLiteAssetException extends SQLiteException {
public SQLiteAssetException() {}
public SQLiteAssetException(String error) {
super(error);
}
}
}
i dont know what im doing wrong here is the log console
02-02 07:51:17.964 2431-2431/? E/AndroidRuntime:
java.lang.RuntimeException: Unable to start activity
ComponentInfo{com.example.mario.wimwo/com.example.mario.wimwo.View_Activities.Start_Activity}: android.database.sqlite.SQLiteCantOpenDatabaseException: unknown error (code 14): Could not open database
02-02 07:51:17.964 2431-2431/? E/AndroidRuntime: at com.example.mario.wimwo.BDAssets.SQLiteAssetHelper.getReadableDatabase(SQLiteAssetHelper.java:264)
02-02 07:51:17.964 2431-2431/? E/AndroidRuntime: at com.example.mario.wimwo.Dao.CamisetaDao.<init>(CamisetaDao.java:21)
02-02 07:51:17.964 2431-2431/? E/AndroidRuntime: at com.example.mario.wimwo.Control.Controlador.getCamisetas(Controlador.java:21)
02-02 07:51:17.964 2431-2431/? E/AndroidRuntime: at com.example.mario.wimwo.View_Activities.Start_Activity.pintarCamiseta(Start_Activity.java:29)
02-02 07:51:17.964 2431-2431/? E/AndroidRuntime: at com.example.mario.wimwo.View_Activities.Start_Activity.onCreate(Start_Activity.java:25)
Aucun commentaire:
Enregistrer un commentaire