Custom abstract class customsqliteopenhelper for free storage of sqlitedb (eg. sdcard)

Write an abstract class CustomSQLiteOpenHelper and slightly modify SQLiteOpenHelper to store the database to sdcard. You can access sdcard directly.

Import java. io. file; import android. content. context; import android. database. sqlite. SQLiteDatabase; import android. database. sqlite. SQLiteException; import android. database. sqlite. SQLiteDatabase. cursorFactory; import android. util. log;/*** A helper class to manage database creation and version management. * You create a subclass implementing {@ link # onCreate}, {@ link # onUpgrade} and * optionally {@ link # onO Pen}, and this class takes care of opening the database * if it exists, creating it if it does not, and upgrading it as necessary. * Transactions are used to make sure the database is always in a sensible state. * <p> For an example, see the NotePadProvider class in the NotePad sample application, * in the <em> samples/</em> directory of the SDK. </p> */public abstract class CustomSQLiteOpenHelper {priva Te static final String TAG = CustomSQLiteOpenHelper. class. getSimpleName (); private final Context mContext; private final String mName; private final CursorFactory mFactory; private final int mNewVersion; private SQLiteDatabase mDatabase = null; private boolean mIsInitializing = false; /*** Create a helper object to create, open, and/or manage a database. * The database is not actually created or Opened until one of * {@ link # getWritableDatabase} or {@ link # getReadableDatabase} is called. ** @ param context to use to open or create the database * @ param name of the database file, or null for an in-memory database * @ param factory to use for creating cursor objects, or null for the default * @ param version number of the database (starting at 1 ); if the database is older, * {@ link # onUpgrade} Will be used to upgrade the database */public CustomSQLiteOpenHelper (Context context, String name, CursorFactory factory, int version) {if (version <1) throw new IllegalArgumentException ("Version must be> = 1, was" + version); mContext = context; mName = name; mFactory = factory; mNewVersion = version ;} /*** Create and/or open a database that will be used for reading and writing. * Once op Ened successfully, the database is cached, so you can call this * method every time you need to write to the database. make sure to call * {@ link # close} when you no longer need it. ** <p> Errors such as bad permissions or a full disk may cause this operation * to fail, but future attempts may succeed if the problem is fixed. </p> ** @ throws SQLiteException if the database cannot be opened for wri Ting * @ return a read/write database object valid until {@ link # close} is called */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 ");} // If we have a read-only database open, someone cocould be using it // (though they shouldn't ), which wowould cause a lock to be held on // the file, and our attempts to open the database read-write wocould // fail Waiting for the file lock. to prevent that, we acquire the // lock on the read-only database, which shuts out other users. boolean success = false; SQLiteDatabase db = null; try {mIsInitializing = true; if (mName = null) {db = SQLiteDatabase. create (null);} else {String path = getDatabasePath (mName ). getPath (); db = SQLiteDatabase. openOrCreateDatabase (path, mFactory);} int version = db. getVers Ion (); if (version! = MNewVersion) {db. beginTransaction (); try {if (version = 0) {onCreate (db);} else {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 = db ;}else {if (db! = Null) db. close () ;}}/ *** Create and/or open a database. this will be the same object returned by * {@ link # getWritableDatabase} unless some problem, such as a full disk, * requires the database to be opened read-only. in that case, a read-only * database object will be returned. if the problem is fixed, a future call * to {@ link # getWritableDatabase} may succeed, in which case the read-only * Database object will be closed and the read/write object will be returned * in the future. ** @ throws SQLiteException if the database cannot be opened * @ return a database object valid until {@ link # getWritableDatabase} * or {@ link # close} is called. */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 = getDatabasePath (mName ). getPath (); db = SQLiteDatabase. openDatabase (path, mFactory, SQLiteDatabase. OPEN_READWRITE); 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. */public synchronized void close () {if (mIsInitializing) throw new IllegalStateException ("Closed during initialization"); if (mDatabase! = Null & mDatabase. isOpen () {mDatabase. close (); mDatabase = null;}/*** Called when the database is created for the first time. this is where the * creation of tables and the initial population of the tables shoshould happen. ** @ param db The database. */public abstract void onCreate (SQLiteDatabase db);/*** Called when the database needs to be upgraded. the implementation * shocould use this method to drop tables, add tables, or do anything else it * needs to upgrade to the new schema version. *** <p> The SQLite alter table documentation can be found * <a href = "http://sqlite.org/lang_altertable.html"> here </a>. if you add new columns * you can use alter table to insert them into a live table. if you rename or remove columns * you can use alter table to rename the old table, then create the new table and then * populate the new table with the contents of the old table. ** @ param db The database. * @ param oldVersion The old database version. * @ param newVersion The new database version. */public abstract void onUpgrade (SQLiteDatabase db, int oldVersion, int newVersion);/*** Called when the database has been opened. * Override method shocould check {@ link SQLiteDatabase # isReadOnly} before * updating the database. ** @ param db The database. */public void onOpen (SQLiteDatabase db) {}/ *** get the DB storage path */public File getDatabasePath (String dbpath) {return new File (Environment. getExternalStorageDirectory () + "/" + dbpath );}}