（干货）Android入门完整项目：一个有定时提醒功能的备忘录

本文原创地址，我的博客：https://jsbintask.cn/2019/02/23/android/android-memo/(食用效果最佳)，转载请注明出处!

介绍

今天给大家分享一个以前学习android时做的小项目，一个带有定时提醒功能的备忘录，主要用到RecycleView, sqlite, butterknife，效果如下：

apk地址

详细功能实现

建立db，编写db helper类

1. 新建一个常量类，包含所有操作db的语句，ColumnContacts:

public class ColumnContacts {
   
    public static final String EVENT_TABLE_NAME = "event";
    public static final String EVENT_TITLE_COLUMN = "title";
    public static final String EVENT_CONTENT_COLUMN = "content";
    public static final String EVENT_CREATED_TIME_COLUMN = "created_time";
    public static final String EVENT_UPDATED_TIME_COLUMN = "updated_time";
    public static final String EVENT_REMIND_TIME_COLUMN = "remind_time";
    public static final String EVENT_IS_IMPORTANT_COLUMN = "is_important";
    public static final String EVENT_IS_CLOCKED = "is_clocked";
}

2. 新建一个DBTemplate,此处用到设计模式模板方法，所以还包含一个回调接口DBCallbackk

public class DBTemplate<T> {
   
    private DBOpenHelper dbHelper;

    public DBTemplate() {
   
        dbHelper = new DBOpenHelper();
    }

    public T queryOne(String sql, DBCallback<T> callback, String...args) {
   
        T t = null;
        SQLiteDatabase db = dbHelper.getReadableDatabase();
        Cursor cursor = db.rawQuery(sql, args);
        if (cursor != null && cursor.moveToNext()) {
   
            t = callback.cursorToInstance(cursor);
            cursor.close();
        }

        return t;
    }

    public List<T> query(String sql, DBCallback<T> callback, String... args) {
   
        List<T> list = new ArrayList<>();
        SQLiteDatabase db = dbHelper.getReadableDatabase();
        Cursor cursor = db.rawQuery(sql, args);
        if (cursor != null) {
   
            while (cursor.moveToNext()) {
   
                T t = callback.cursorToInstance(cursor);
                list.add(t);
            }
            cursor.close();
        }

        return list;
    }

    public long create(String table, ContentValues values) {
   
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        return db.insert(table, null, values);
    }

    public int remove(String table, String whereConditions, String... args) {
   
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        return db.delete(table, whereConditions, args);
    }

    public int getLatestId(String table) {
   
        SQLiteDatabase db = dbHelper.getReadableDatabase();
        String sql = "SELECT MAX(" + BaseColumns._ID + ") FROM " + table;
        Cursor cursor = db.rawQuery(sql, new String[]{
   });
        int result = -1;
        if (cursor != null && cursor.moveToNext()) {
   
            result = cursor.getInt(0);
            cursor.close();
        }
        return result;
    }

    public int update(String table, ContentValues contentValues, String whereConditions, String... args) {
   
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        return db.update(table, contentValues, whereConditions, args);
    }
}

public interface DBCallback <T> {
   
    /**
     * Gets a instance of T by cursor
     */
    T cursorToInstance(Cursor cursor);
}

3. 新建一个类继承SQLiteOpenHelper，DBOpenHelper，用于启动app时创建数据库，并且初始化数据，加入一条记录:

public class DBOpenHelper extends SQLiteOpenHelper {
   
    private static final String TAG = DBOpenHelper.class.getSimpleName();
    private static final int VERSION = 1;
    private static final String DB_NAME = "memo.db";

    public DBOpenHelper() {
   
        super(MemoApplication.getContext(), DB_NAME, null, VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
   
        /*第一次初始化app，创建表结构 */
        db.execSQL("CREATE TABLE IF NOT EXISTS " + ColumnContacts.EVENT_TABLE_NAME + "( "
                    + BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
                    + ColumnContacts.EVENT_TITLE_COLUMN + " text, "
                    + ColumnContacts.EVENT_CONTENT_COLUMN + " text, "
                    + ColumnContacts.EVENT_CREATED_TIME_COLUMN + " datetime, "
                    + ColumnContacts.EVENT_UPDATED_TIME_COLUMN + " datetime, "
                    + ColumnContacts.EVENT_REMIND_TIME_COLUMN + " datetime, "
                    + ColumnContacts.EVENT_IS_IMPORTANT_COLUMN + " INTEGER, "
                    + ColumnContacts.EVENT_IS_CLOCKED + " INTEGER"
        + ")");

        String sql = "INSERT INTO " + ColumnContacts.EVENT_TABLE_NAME + " VALUES(NULL, ?, ?, ?, ?, ?, ?, ?)";
        db.beginTransaction();
        db.execSQL(sql, new Object[]{
   "jsbintask->memo",
                "Memo是一个小巧方便带有闹铃功能的记事本app，主要使用butterknife和recycleview，clockmanager构建\n" +
                        "git地址：https://github.com/jsbintask22/memo.git",
                "2018-04-25 17:28:23",
                "2018-04-25 17:28",
                "2018-04-25 17:28",
                0, 0});
        db.setTransactionSuccessful();
        db.endTransaction();
    }

    /*版本更新时会执行该方法，如版本变更 => 2  */
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
   
        //Nothing to do
    }
}

编写dao层

记事本中是包含一个实体类，Event，编写实体类和dao层代码对该表进行增删改查
Event:

public class Event implements BaseColumns, Parcelable{
   
    //id
    private Integer mId;
    //事件
    private String mTitle;
    //事件内容
    private String mContent;
    //创建时间
    private String mCreatedTime;

    public Integer getmIsClocked() {
   
        return mIsClocked;
    }

    public void setmIsClocked(Integer mIsClocked) {
   
        this.mIsClocked = mIsClocked;
    }

    //更新时间
    private String mUpdatedTime;
    //闹钟表示位：该事件是否已经响过铃了，默认没有
    private Integer mIsClocked = 0;

    public Event(){
   }

    protected Event(Parcel in) {
   
        if (in.readByte() == 0) {
   
            mId = null;
        } else {
   
            mId = in.readInt();
        }
        mTitle = in.readString();
        mContent = in.readString();
        mCreatedTime = in.readString();
        mUpdatedTime = in.readString();
        if (in.readByte() == 0) {
   
            mIsClocked = null;
        } else {
   
            mIsClocked = in.readInt();
        }
        if (in.readByte() == 0) {
   
            mIsImportant = null;
        } else {
   
            mIsImportant = in.readInt();
        }
        mRemindTime = in.readString();
    }

    public static final Creator<Event> CREATOR = new Creator<Event>() {
   
        @Override
        public Event createFromParcel(Parcel in) {
   
            return new Event(in);
        }

        @Override
        public Event[] newArray(int size) {
   
            return new Event[size];
        }
    };

    public Integer getmIsImportant() {
   
        return mIsImportant;
    }

    public void setmIsImportant(Integer mIsImportant) {
   
        this.mIsImportant = mIsImportant;
    }

    private Integer mIsImportant;

    public Integer getmId() {
   
        return mId;
    }

    public void setmId(Integer mId) {
   
        this.mId = mId;
    }

    public String getmTitle() {
   
        return mTitle;
    }

    public void setmTitle(String mTitle) {
   
        this.mTitle = mTitle;
    }

    public String getmContent() {
   
        return mContent;
    }

    public void setmContent(String mContent) {
   
        this.mContent = mContent;
    }

    public String getmCreatedTime() {
   
        return mCreatedTime;
    }

    public void setmCreatedTime(String mCreatedTime) {
   
        this.mCreatedTime = mCreatedTime;
    }

    public String getmUpdatedTime() {
   
        return mUpdatedTime;
    }

    public void setmUpdatedTime(String mUpdatedTime) {
   
        this.mUpdatedTime = mUpdatedTime;
    }

    public String getmRemindTime() {
   
        return mRemindTime;
    }

    public void setmRemindTime(String mRemindTime) {
   
        this.mRemindTime = mRemindTime;
    }

    private String mRemindTime;

    @Override
    public int describeContents() {
   
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
   
        if (mId == null) {
   
            dest.writeByte((byte) 0);
        } else {
   
            dest.writeByte((byte) 1);
            dest.writeInt(mId);
        }
        dest.writeString(mTitle);
        dest.writeString(mContent);
        dest.writeString(mCreatedTime);
        dest.writeString(mUpdatedTime);
        if (mIsClocked == null) {
   
            dest.writeByte((byte) 0);
        } else {
   
            dest.writeByte((byte) 1);
            dest.writeInt(mIsClocked);
        }
        if (mIsImportant == null) {
   
            dest.writeByte((byte) 0);
        } else {
   
            dest.writeByte((byte) 1);
            dest.writeInt(mIsImportant);
        }
        dest.writeString(mRemindTime);
    }
}

值得注意的是ÿ