数据库SQLiteDatabase

package com.baclock.entity;

import android.provider.BaseColumns;

/**
 * Created by Jack on 5/4/2016.
 */
public final class DBEntity {
    // To prevent someone from accidentally instantiating the LocationTrackEntity class,
    // give it an empty constructor.
    public DBEntity() {};

    public static abstract class SyncData implements BaseColumns {
        public static final String TABLE_NAME = "syncdata";
        public static final String COLUMN_NAME_ACTION_TYPE = "action_type";
        public static final String COLUMN_NAME_TOKEN = "token";
        public static final String COLUMN_NAME_TOKEN_SECRET = "token_secret";
        public static final String COLUMN_NAME_LATITUDE = "latitude";
        public static final String COLUMN_NAME_LONGITUDE = "longitude";
        public static final String COLUMN_NAME_IP_ADDRESS = "ip";
        public static final String COLUMN_NAME_HOST_NAME = "host_name";
        public static final String COLUMN_NAME_REASON_START = "reason_start";
        public static final String COLUMN_NAME_REASON_END = "reason_end";
        public static final String COLUMN_NAME_REASON = "reason";
        public static final String COLUMN_NAME_LOCAL_DATE = "local_date";
        public static final String COLUMN_NAME_SERVICE = "service";
    }
}

　　

package com.baclock.utils;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

import com.baclock.entity.DBEntity.*;

/**
 * Created by Jack on 5/4/2016.
 */
public class DBHelper extends SQLiteOpenHelper {

    // If you change the database schema, you must increment the database version.
    public static final int DATABASE_VERSION = 2;
    public static final String DATABASE_NAME = "BAClock.db";

    private static final String TEXT_TYPE = " TEXT";
    private static final String COMMA_SEP = ",";

    private static final String SQL_CREATE_SYNC_DATA =
            "CREATE TABLE " + SyncData.TABLE_NAME + " (" +
                    SyncData._ID + " INTEGER PRIMARY KEY," +
                    SyncData.COLUMN_NAME_ACTION_TYPE + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_TOKEN + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_TOKEN_SECRET + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_LATITUDE + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_LONGITUDE + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_IP_ADDRESS + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_HOST_NAME + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_REASON_START + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_REASON_END + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_REASON + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_LOCAL_DATE + TEXT_TYPE + COMMA_SEP +
                    SyncData.COLUMN_NAME_SERVICE + TEXT_TYPE +
                    " )";

    private static final String SQL_DELETE_SYNC_DATA =
            "DROP TABLE IF EXISTS " + SyncData.TABLE_NAME;

    public DBHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(SQL_CREATE_SYNC_DATA);
    }
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // This database is only a cache for online data, so its upgrade policy is
        // to simply to discard the data and start over
        db.execSQL(SQL_DELETE_SYNC_DATA);
        onCreate(db);
    }
    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        onUpgrade(db, oldVersion, newVersion);
    }
}

　　

    public static DBHelper dbHelper = null;
    public static SQLiteDatabase dbReader = null;
    public static SQLiteDatabase dbWriter = null;

try {
            dbHelper = new DBHelper(getBaseContext());
            dbWriter = dbHelper.getWritableDatabase();
            dbReader = dbHelper.getReadableDatabase();
        } catch (Exception e) {
            e.printStackTrace();
        }

// Read data
try {
            String[] scheduled_interval = {
                    DBEntity.ScheduledInterval._ID,
                    DBEntity.ScheduledInterval.COLUMN_NAME_SCHEDULED_INTERVAL,
                    DBEntity.ScheduledInterval.COLUMN_NAME_SCHEDULED_FROM,
                    DBEntity.ScheduledInterval.COLUMN_NAME_SCHEDULED_TO
            };

            Cursor cursor = MainActivity.dbReader.query(
                    DBEntity.ScheduledInterval.TABLE_NAME,  // The table to query
                    scheduled_interval,                               // The columns to return
                    null,                                // The columns for the WHERE clause
                    null,                            // The values for the WHERE clause
                    null,                                     // don't group the rows
                    null,                                     // don't filter by row groups
                    DBEntity.ScheduledInterval._ID                                 // The sort order
            );

            if (cursor.getCount() > 0) {
                while (cursor.moveToNext()) {
                    FrequencyEntity entity = new FrequencyEntity();
                    entity.setScheduledInterval(cursor.getInt(cursor.getColumnIndex(DBEntity.ScheduledInterval.COLUMN_NAME_SCHEDULED_INTERVAL)));
                    entity.setScheduledFrom(cursor.getString(cursor.getColumnIndex(DBEntity.ScheduledInterval.COLUMN_NAME_SCHEDULED_FROM)));
                    entity.setScheduledTo(cursor.getString(cursor.getColumnIndex(DBEntity.ScheduledInterval.COLUMN_NAME_SCHEDULED_TO)));
                    MainActivity.frequencyArrayList.add(entity);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

// Insert Data
ContentValues params = new ContentValues();
            params.put(DBEntity.SyncData.COLUMN_NAME_ACTION_TYPE, "");
            params.put(DBEntity.SyncData.COLUMN_NAME_TOKEN, PersistenceUtils.getSharedInstance().get("token", ""));
            params.put(DBEntity.SyncData.COLUMN_NAME_TOKEN_SECRET, PersistenceUtils.getSharedInstance().get("token_secret", ""));
            if ("".equals(AppUtils.getSharedInstance().getIp()))
                params.put(DBEntity.SyncData.COLUMN_NAME_IP_ADDRESS, AppUtils.getSharedInstance().getLocalIP(this));
            else
                params.put(DBEntity.SyncData.COLUMN_NAME_IP_ADDRESS, AppUtils.getSharedInstance().getIp());
            params.put(DBEntity.SyncData.COLUMN_NAME_HOST_NAME, AppUtils.getSharedInstance().getPhoneName());

            if (GPSLocationManager.getInstance().getMyLocation() != null) {
                params.put(DBEntity.SyncData.COLUMN_NAME_LATITUDE, GPSLocationManager.getInstance().getMyLocation().getLatitude());
                params.put(DBEntity.SyncData.COLUMN_NAME_LONGITUDE, GPSLocationManager.getInstance().getMyLocation().getLongitude());
            } else {
                params.put(DBEntity.SyncData.COLUMN_NAME_LATITUDE, 0);
                params.put(DBEntity.SyncData.COLUMN_NAME_LONGITUDE, 0);
            }
            params.put(DBEntity.SyncData.COLUMN_NAME_REASON_START, "");
            params.put(DBEntity.SyncData.COLUMN_NAME_REASON_END, "");
            params.put(DBEntity.SyncData.COLUMN_NAME_REASON, "");

            SimpleDateFormat sdf0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);
            Date curDate0 = new Date();
            String date0 = sdf0.format(curDate0);

            SimpleDateFormat sdf1 = new SimpleDateFormat("hh:mm:ss aa", Locale.US);
            String time = sdf1.format(curDate0);

            SimpleDateFormat sdf2 = new SimpleDateFormat("E, MMM dd", Locale.US);
            String date1 = sdf2.format(curDate0);

            Log.e("date", date1 + " " + time);

            params.put(DBEntity.SyncData.COLUMN_NAME_LOCAL_DATE, date0);
            params.put(DBEntity.SyncData.COLUMN_NAME_SERVICE, "ClockIn");
            long newRowId = dbWriter.insert(DBEntity.SyncData.TABLE_NAME, null, params);

// Delete Data
if (rowid > 0) {
                    // Define 'where' part of query.
                    String selection = DBEntity.ScheduledData._ID + " = ?";
                    // Specify arguments in placeholder order.
                    String[] selectionArgs = { String.valueOf(rowid) };
                    // Issue SQL statement.
                    MainActivity.dbWriter.delete(DBEntity.ScheduledData.TABLE_NAME, selection, selectionArgs);
                }