SDSQliteOpenHelper将数据库建立在SD卡上

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.os.Environment;
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 #onOpen}, 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 SDSQLiteOpenHelper {
        private static final String TAG = SDSQLiteOpenHelper.class.getSimpleName();
        public static String sdcardpath;
        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 SDSQLiteOpenHelper(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 opened 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 writing
         * @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 could be using it
            // (though they shouldn't), which would cause a lock to be held on
            // the file, and our attempts to open the database read-write would
            // 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.getVersion();
                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;
            }
        }
                              
        public File getDatabasePath(String name)//得到数据库位置可以看需求相应更改
        {
                if(this.ExistSDCard()){
                    sdcardpath = Environment.getExternalStorageDirectory().getPath()+"/";
                                           
                }
                return new File(sdcardpath+ name);
        }
        /**
         * Called when the database is created for the first time. This is where the
         * creation of tables and the initial population of the tables should happen.
         *
         * @param db The database.
         */
        public abstract void onCreate(SQLiteDatabase db);
        /**
         * Called when the database needs to be upgraded. The implementation
         * should 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 should check {@link SQLiteDatabase#isReadOnly} before
         * updating the database.
         *
         * @param db The database.
         */
        public void onOpen(SQLiteDatabase db) {}
                               
        private boolean ExistSDCard() {  //判断SD卡是否存在
            Log.d("Exitsdcard",String.valueOf(android.os.Environment.getExternalStorageState().equals( 
              android.os.Environment.MEDIA_MOUNTED)));
            if (android.os.Environment.getExternalStorageState().equals( 
              android.os.Environment.MEDIA_MOUNTED)) { 
             return true; 
            } else 
             return false; 
           } 
    }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.