README.md

@@ -1,2 +0,0 @@
-# duanxujing111
-

src/data/Contact.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.data;
+
+import android.content.Context; // 用于访问应用环境数据，如数据库
+import android.database.Cursor; // 用于读取数据库查询结果
+import android.provider.ContactsContract.CommonDataKinds.Phone; // 提供电话号码相关的信息
+import android.provider.ContactsContract.Data; // 提供关于数据的信息
+import android.telephony.PhoneNumberUtils; // 提供电话号码处理的工具方法
+import android.util.Log; // 用于调试
+
+import java.util.HashMap; // 用于存储键值对数据
+
+public class Contact {
+    // 创建一个HashMap来缓存电话号码和对应的联系人姓名，以便快速查找
+    private static HashMap<String, String> sContactCache;
+    private static final String TAG = "Contact"; // 日志标签，便于调试时查找相关日志
+
+    // 定义一个电话号码查询的SQL选择条件字符串
+    // 该条件用于查找与给定电话号码匹配的联系人
+    private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
+            + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
+            + " AND " + Data.RAW_CONTACT_ID + " IN "
+            + "(SELECT raw_contact_id "
+            + " FROM phone_lookup"
+            + " WHERE min_match = '+')";
+
+    /**
+     * 根据电话号码获取联系人姓名的方法
+     * @param context 应用上下文对象，用于访问应用环境数据
+     * @param phoneNumber 要查询的电话号码
+     * @return 如果找到匹配的联系人，则返回联系人姓名；否则返回null
+     */
+    public static String getContact(Context context, String phoneNumber) {
+        // 如果缓存为空，初始化缓存
+        if(sContactCache == null) {
+            sContactCache = new HashMap<String, String>();
+        }
+
+        // 如果缓存中已经存在该电话号码对应的联系人姓名，直接返回
+        if(sContactCache.containsKey(phoneNumber)) {
+            return sContactCache.get(phoneNumber);
+        }
+
+        // 替换CALLER_ID_SELECTION中的'+'为电话号码的最小匹配字符串
+        // PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)用于生成电话号码的最小匹配字符串
+        String selection = CALLER_ID_SELECTION.replace("+",
+                PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+
+        // 查询数据库，获取与给定电话号码匹配的联系人姓名
+        // Data.CONTENT_URI用于指定查询的URI
+        // new String [] { Phone.DISPLAY_NAME }指定查询的字段为联系人显示名称
+        // selection为查询条件
+        // new String[] { phoneNumber }为条件参数
+        // 最后一个参数null表示不进行排序
+        Cursor cursor = context.getContentResolver().query(
+                Data.CONTENT_URI,
+                new String [] { Phone.DISPLAY_NAME },
+                selection,
+                new String[] { phoneNumber },
+                null);
+
+        // 检查查询结果是否为空，如果不为空，则移动到第一行数据
+        if (cursor != null && cursor.moveToFirst()) {
+            try {
+                // 获取当前行的联系人姓名
+                String name = cursor.getString(0);
+                // 将电话号码和联系人姓名存入缓存
+                sContactCache.put(phoneNumber, name);
+                // 返回联系人姓名
+                return name;
+            } catch (IndexOutOfBoundsException e) { // 捕获可能的索引越界异常
+                // 如果发生异常，输出错误日志
+                Log.e(TAG, " Cursor get string error " + e.toString());
+                // 返回null表示未找到联系人姓名
+                return null;
+            } finally {
+                // 无论是否找到联系人姓名，都关闭Cursor以释放资源
+                cursor.close();
+            }
+        } else {
+            // 如果未找到匹配的联系人，输出调试日志
+            Log.d(TAG, "No contact matched with number:" + phoneNumber);
+            // 返回null表示未找到联系人姓名
+            return null;
+        }
+    }

src/data/Notes.java

@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.data;
+
+import android.net.Uri;
+
+// 定义Notes类
+public class Notes {
+    // 定义内容提供者的授权名
+    public static final String AUTHORITY = "micode_notes";
+    // 定义日志标签
+    public static final String TAG = "Notes";
+    // 定义笔记类型ID
+    public static final int TYPE_NOTE = 0;
+    // 定义文件夹类型ID
+    public static final int TYPE_FOLDER = 1;
+    // 定义系统类型ID
+    public static final int TYPE_SYSTEM = 2;
+
+    /**
+     * 以下ID是系统文件夹的标识符
+     * {@link Notes#ID_ROOT_FOLDER} 是默认文件夹
+     * {@link Notes#ID_TEMPARAY_FOLDER} 是用于不属于任何文件夹的笔记
+     * {@link Notes#ID_CALL_RECORD_FOLDER} 用于存储电话记录
+     */
+    // 定义根文件夹ID
+    public static final int ID_ROOT_FOLDER = 0;
+    // 定义临时文件夹ID
+    public static final int ID_TEMPARAY_FOLDER = -1;
+    // 定义通话记录文件夹ID
+    public static final int ID_CALL_RECORD_FOLDER = -2;
+    // 定义回收站文件夹ID
+    public static final int ID_TRASH_FOLER = -3;
+
+    // 定义Intent传递的额外信息键
+    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
+    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
+    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
+    public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
+    public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
+    public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
+
+    // 定义小部件类型ID
+    public static final int TYPE_WIDGET_INVALIDE = -1;
+    public static final int TYPE_WIDGET_2X = 0;
+    public static final int TYPE_WIDGET_4X = 1;
+
+    // 定义数据常量内部类
+    public static class DataConstants {
+        // 文本笔记内容类型
+        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
+        // 通话笔记内容类型
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
+    }
+
+    /**
+     * 查询所有笔记和文件夹的Uri
+     */
+    // 查询笔记和文件夹的Uri
+    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
+
+    /**
+     * 查询数据的Uri
+     */
+    // 查询数据的Uri
+    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
+
+    // 定义笔记列接口
+    public interface NoteColumns {
+        /**
+         * 行的唯一ID
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String ID = "_id";
+
+        /**
+         * 笔记或文件夹的父ID
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String PARENT_ID = "parent_id";
+
+        /**
+         * 笔记或文件夹的创建日期
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String CREATED_DATE = "created_date";
+
+        /**
+         * 笔记或文件夹的最新修改日期
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String MODIFIED_DATE = "modified_date";
+
+        /**
+         * 笔记的提醒日期
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String ALERTED_DATE = "alert_date";
+
+        /**
+         * 文件夹的名称或笔记的文本内容摘要
+         * <P> 类型: TEXT </P>
+         */
+        public static final String SNIPPET = "snippet";
+
+        /**
+         * 笔记的小部件ID
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String WIDGET_ID = "widget_id";
+
+        /**
+         * 笔记的小部件类型
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String WIDGET_TYPE = "widget_type";
+
+        /**
+         * 笔记的背景颜色ID
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String BG_COLOR_ID = "bg_color_id";
+
+        /**
+         * 对于文本笔记，它没有附件，对于多媒体笔记，它至少有一个附件
+         * <P> 类型: INTEGER </P>
+         */
+        public static final String HAS_ATTACHMENT = "has_attachment";
+
+        /**
+         * 文件夹中的笔记数量
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String NOTES_COUNT = "notes_count";
+
+        /**
+         * 行的类型：文件夹或笔记
+         * <P> 类型: INTEGER </P>
+         */
+        public static final String TYPE = "type";
+
+        /**
+         * 最后的同步ID
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String SYNC_ID = "sync_id";
+
+        /**
+         * 标志表示本地是否被修改过
+         * <P> 类型: INTEGER </P>
+         */
+        public static final String LOCAL_MODIFIED = "local_modified";
+
+        /**
+         * 移动到临时文件夹之前的原始父ID
+         * <P> 类型: INTEGER </P>
+         */
+        public static final String ORIGIN_PARENT_ID = "origin_parent_id";
+
+        /**
+         * G任务ID
+         * <P> 类型: TEXT </P>
+         */
+        public static final String GTASK_ID = "gtask_id";
+
+        /**
+         * 版本号
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String VERSION = "version";
+    }
+
+    // 定义数据列接口
+    public interface DataColumns {
+        /**
+         * 行的唯一ID
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String ID = "_id";
+
+        /**
+         * 由该行所代表的项目的MIME类型
+         * <P> 类型: Text </P>
+         */
+        public static final String MIME_TYPE = "mime_type";
+
+        /**
+         * 引用到该数据所属笔记的ID
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String NOTE_ID = "note_id";
+
+        /**
+         * 笔记或文件夹的创建日期
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String CREATED_DATE = "created_date";
+
+        /**
+         * 笔记或文件夹的最新修改日期
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String MODIFIED_DATE = "modified_date";
+
+        /**
+         * 数据的内容
+         * <P> 类型: TEXT </P>
+         */
+        public static final String CONTENT = "content";
+
+        /**
+         * 泛型数据列，其含义是 {@link #MIMETYPE} 特定的，用于整数类型数据
+         * <P> 类型: INTEGER </P>
+         */
+        public static final String DATA1 = "data1";
+
+        /**
+         * 泛型数据列，其含义是 {@link #MIMETYPE} 特定的，用于整数类型数据
+         * <P> 类型: INTEGER </P>
+         */
+        public static final String DATA2 = "data2";
+
+        /**
+         * 泛型数据列，其含义是 {@link #MIMETYPE} 特定的，用于文本类型数据
+         * <P> 类型: TEXT </P>
+         */
+        public static final String DATA3 = "data3";
+
+        /**
+         * 泛型数据列，其含义是 {@link #MIMETYPE} 特定的，用于文本类型数据
+         * <P> 类型: TEXT </P>
+         */
+        public static final String DATA4 = "data4";
+
+        /**
+         * 泛型数据列，其含义是 {@link #MIMETYPE} 特定的，用于文本类型数据
+         * <P> 类型: TEXT </P>
+         */
+        public static final String DATA5 = "data5";
+    }
+
+    // 定义文本笔记内部类，继承自DataColumns
+    public static final class TextNote implements DataColumns {
+        /**
+         * 模式表示文本是否在检查列表模式：1表示检查列表模式，0表示普通模式
+         * <P> 类型: Integer </P>
+         */
+        public static final String MODE = DATA1;
+
+        // 定义检查列表模式的值
+        public static final int MODE_CHECK_LIST = 1;
+
+        // 定义文本笔记的内容类型
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
+
+        // 定义文本笔记的项目内容类型
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
+
+        // 定义文本笔记的Uri
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
+    }
+
+    // 定义通话笔记内部类，继承自DataColumns
+    public static final class CallNote implements DataColumns {
+        /**
+         * 通话记录的通话日期
+         * <P> 类型: INTEGER (long) </P>
+         */
+        public static final String CALL_DATE = DATA1;
+
+        /**
+         * 通话记录的电话号码
+         * <P> 类型: TEXT </P>
+         */
+        public static final String PHONE_NUMBER = DATA3;
+
+        // 定义通话笔记的内容类型
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
+
+        // 定义通话笔记的项目内容类型
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
+
+        // 定义通话笔记的Uri
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
+    }
+}
+

src/data/NotesDatabaseHelper.java

@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.data;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+
+// 定义一个数据库帮助类，继承自 SQLiteOpenHelper
+public class NotesDatabaseHelper extends SQLiteOpenHelper {
+    // 数据库名称
+    private static final String DB_NAME = "note.db";
+
+    // 数据库版本号，用于数据库升级操作
+    private static final int DB_VERSION = 4;
+
+    // 定义表的接口
+    public interface TABLE {
+        // 笔记表名称
+        public static final String NOTE = "note";
+
+        // 数据表名称
+        public static final String DATA = "data";
+    }
+
+    // 日志标签
+    private static final String TAG = "NotesDatabaseHelper";
+
+    // 单例实例，用于确保数据库帮助类在整个应用中只有一个实例
+    private static NotesDatabaseHelper mInstance;
+
+    // 创建笔记表的SQL语句
+    private static final String CREATE_NOTE_TABLE_SQL =
+        "CREATE TABLE " + TABLE.NOTE + "(" +
+            NoteColumns.ID + " INTEGER PRIMARY KEY," + // 笔记ID，主键
+            NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + // 父文件夹ID，默认为0
+            NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," + // 提醒日期，默认为0
+            NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," + // 背景颜色ID，默认为0
+            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 创建日期，默认为当前时间
+            NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," + // 是否有附件，默认为0
+            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 修改日期，默认为当前时间
+            NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," + // 笔记数量，默认为0
+            NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," + // 笔记内容摘要，默认为空
+            NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," + // 笔记类型，默认为0
+            NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," + // 小部件ID，默认为0
+            NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," + // 小部件类型，默认为-1
+            NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," + // 同步ID，默认为0
+            NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," + // 是否本地修改，默认为0
+            NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + // 原始父文件夹ID，默认为0
+            NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," + // Google任务ID，默认为空
+            NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" + // 版本号，默认为0
+        ")";
+
+    // 创建数据表的SQL语句
+    private static final String CREATE_DATA_TABLE_SQL =
+        "CREATE TABLE " + TABLE.DATA + "(" +
+            DataColumns.ID + " INTEGER PRIMARY KEY," + // 数据ID，主键
+            DataColumns.MIME_TYPE + " TEXT NOT NULL," + // MIME类型，默认为0
+            DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," + // 关联的笔记ID，默认为0
+            NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 创建日期，默认为当前时间
+            NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 修改日期，默认为当前时间
+            DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," + // 数据内容，默认为空
+            DataColumns.DATA1 + " INTEGER," + // 数据字段1，整型
+            DataColumns.DATA2 + " INTEGER," + // 数据字段2，整型
+            DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," + // 数据字段3，默认为空
+            DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," + // 数据字段4，默认为空
+            DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" + // 数据字段5，默认为空
+        ")";
+
+    // 创建数据表的索引SQL语句
+    private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
+        "CREATE INDEX IF NOT EXISTS note_id_index ON " +
+        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
+
+    /**
+     * 当笔记移动到文件夹时，增加文件夹的笔记数量
+     */
+    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER increase_folder_count_on_update "+ // 创建触发器
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + // 在笔记表的PARENT_ID更新后
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE + // 更新笔记表
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + // 笔记数量加1
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + // 父文件夹ID等于新笔记的PARENT_ID
+        " END";
+
+    /**
+     * 当笔记从文件夹移动时，减少文件夹的笔记数量
+     */
+    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER decrease_folder_count_on_update " + // 创建触发器
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + // 在笔记表的PARENT_ID更新后
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE + // 更新笔记表
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + // 笔记数量减1
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + // 文件夹ID等于旧笔记的PARENT_ID
+        "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" + // 仅当笔记数量大于0时更新
+        " END";
+
+    /**
+     * 当插入新笔记时，增加文件夹的笔记数量
+     */
+    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
+        "CREATE TRIGGER increase_folder_count_on_insert " + // 创建触发器
+        " AFTER INSERT ON " + TABLE.NOTE + // 在笔记表插入新数据后
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE + // 更新笔记表
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + // 笔记数量加1
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + // 文件夹ID等于新笔记的PARENT_ID
+        " END";
+
+    /**
+     * 当删除笔记时，减少文件夹的笔记数量
+     */
+    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER decrease_folder_count_on_delete " + // 创建触发器
+        " AFTER DELETE ON " + TABLE.NOTE + // 在笔记表删除数据后
+        " BEGIN " +
+        "  UPDATE " + TABLE.NOTE + // 更新笔记表
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + // 笔记数量减1
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + // 文件夹ID等于旧笔记的PARENT_ID
+        "  AND " + NoteColumns.NOTES_COUNT + ">0;" + // 仅当笔记数量大于0时更新
+        " END";
+
+    /**
+     * 当插入类型为 {@link DataConstants#NOTE} 的数据时，更新笔记的内容摘要
+     */
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_insert " + // 创建触发器
+        " AFTER INSERT ON " + TABLE.DATA + // 在数据表插入新数据后
+        " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + // 仅当MIME类型为NOTE时
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE + // 更新笔记表
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // 笔记摘要设置为新数据的内容
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // 笔记ID等于新数据的NOTE_ID
+        " END";
+
+    /**
+     * 当类型为 {@link DataConstants#NOTE} 的数据更新时，更新笔记的内容摘要
+     */
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_update " + // 创建触发器
+        " AFTER UPDATE ON " + TABLE.DATA + // 在数据表更新数据后
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + // 仅当旧数据的MIME类型为NOTE时
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE + // 更新笔记表
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // 笔记摘要设置为新数据的内容
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // 笔记ID等于新数据的NOTE_ID
+        " END";
+
+    /**
+     * 当类型为 {@link DataConstants#NOTE} 的数据删除时，清空笔记的内容摘要
+     */
+    private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER update_note_content_on_delete " + // 创建触发器
+        " AFTER delete ON " + TABLE.DATA + // 在数据表删除数据后
+        " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" + // 仅当旧数据的MIME类型为NOTE时
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE + // 更新笔记表
+        "   SET " + NoteColumns.SNIPPET + "=''" + // 清空笔记摘要
+        "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" + // 笔记ID等于旧数据的NOTE_ID
+        " END";
+
+    /**
+     * 当删除笔记时，删除关联的数据
+     */
+    private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER delete_data_on_delete " + // 创建触发器
+        " AFTER DELETE ON " + TABLE.NOTE + // 在笔记表删除数据后
+        " BEGIN" +
+        "  DELETE FROM " + TABLE.DATA + // 从数据表中删除数据
+        "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + // 笔记ID等于被删除笔记的ID
+        " END";
+
+    /**
+     * 当删除文件夹时，删除该文件夹下的所有笔记
+     */
+    private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
+        "CREATE TRIGGER folder_delete_notes_on_delete " + // 创建触发器
+        " AFTER DELETE ON " + TABLE.NOTE + // 在笔记表删除数据后
+        " BEGIN" +
+        "  DELETE FROM " + TABLE.NOTE + // 从笔记表中删除数据
+        "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + // 父文件夹ID等于被删除文件夹的ID
+        " END";
+
+    /**
+     * 当文件夹移动到回收站时，将该文件夹下的所有笔记的父文件夹ID设置为回收站ID
+     */
+    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
+        "CREATE TRIGGER folder_move_notes_on_trash " + // 创建触发器
+        " AFTER UPDATE ON " + TABLE.NOTE + // 在笔记表的PARENT_ID更新后
+        " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + // 仅当新的PARENT_ID为回收站ID时
+        " BEGIN" +
+        "  UPDATE " + TABLE.NOTE + // 更新笔记表
+        "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + // 笔记的父文件夹ID设置为回收站ID
+        "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + // 笔记的父文件夹ID等于旧数据的文件夹ID
+        " END";
+
+    // 构造函数，用于初始化数据库名称、版本号等
+    public NotesDatabaseHelper(Context context) {
+        super(context, DB_NAME, null, DB_VERSION);
+    }
+
+    // 创建笔记表和相关触发器
+    public void createNoteTable(SQLiteDatabase db) {
+        db.execSQL(CREATE_NOTE_TABLE_SQL); // 执行创建笔记表的SQL语句
+        reCreateNoteTableTriggers(db); // 重新创建笔记表的触发器
+        createSystemFolder(db); // 创建系统文件夹
+        Log.d(TAG, "note table has been created"); // 输出日志信息
+    }
+
+    // 重新创建笔记表的触发器
+    private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+        // 删除旧的触发器
+        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
+
+        // 创建新的触发器
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
+        db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
+        db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
+        db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
+    }
+
+    // 创建系统文件夹
+    private void createSystemFolder(SQLiteDatabase db) {
+        ContentValues values = new ContentValues();
+
+        // 创建通话记录文件夹
+        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER); // 设置笔记ID为通话记录文件夹ID
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置笔记类型为系统类型
+        db.insert(TABLE.NOTE, null, values); // 插入数据到笔记表
+
+        // 创建根文件夹
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER); // 设置笔记ID为根文件夹ID
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置笔记类型为系统类型
+        db.insert(TABLE.NOTE, null, values); // 插入数据到笔记表
+
+        // 创建临时文件夹
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER); // 设置笔记ID为临时文件夹ID
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置笔记类型为系统类型
+        db.insert(TABLE.NOTE, null, values); // 插入数据到笔记表
+
+        // 创建回收站文件夹
+        values.clear();
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); // 设置笔记ID为回收站文件夹ID
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置笔记类型为系统类型
+        db.insert(TABLE.NOTE, null, values); // 插入数据到笔记表
+    }
+
+    // 创建数据表和相关触发器
+    public void createDataTable(SQLiteDatabase db) {
+        db.execSQL(CREATE_DATA_TABLE_SQL); // 执行创建数据表的SQL语句
+        reCreateDataTableTriggers(db); // 重新创建数据表的触发器
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); // 创建数据表的索引
+        Log.d(TAG, "data table has been created"); // 输出日志信息
+    }
+
+    // 重新创建数据表的触发器
+    private void reCreateDataTableTriggers(SQLiteDatabase db) {
+        // 删除旧的触发器
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
+
+        // 创建新的触发器
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
+    }
+
+    // 获取单例实例的方法
+    static synchronized NotesDatabaseHelper getInstance(Context context) {
+        if (mInstance == null) { // 如果单例实例为空
+            mInstance = new NotesDatabaseHelper(context); // 创建新的数据库帮助类实例
+        }
+        return mInstance; // 返回单例实例
+    }
+
+    // 重写父类的onCreate方法，在数据库第一次创建时执行
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        createNoteTable(db); // 创建笔记表
+        createDataTable(db); // 创建数据表
+    }
+
+    // 重写父类的onUpgrade方法，在数据库版本升级时执行
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        boolean reCreateTriggers = false; // 标记是否需要重新创建触发器
+        boolean skipV2 = false; // 标记是否需要跳过版本2的升级
+
+        // 如果旧版本为1，则执行从版本1升级到版本2的操作
+        if (oldVersion == 1) {
+            upgradeToV2(db); // 执行版本2的升级操作
+            skipV2 = true; // 标记跳过版本2的升级
+            oldVersion++; // 更新版本号
+        }
+
+        // 如果旧版本为2且未跳过版本2，则执行从版本2升级到版本3的操作
+        if (oldVersion == 2 && !skipV2) {
+            upgradeToV3(db); // 执行版本3的升级操作
+            reCreateTriggers = true; // 标记需要重新创建触发器
+            oldVersion++; // 更新版本号
+        }
+
+        // 如果旧版本为3，则执行从版本3升级到版本4的操作
+        if (oldVersion == 3) {
+            upgradeToV4(db); // 执行版本4的升级操作
+            oldVersion++; // 更新版本号
+        }
+
+        // 如果需要重新创建触发器，则重新创建
+        if (reCreateTriggers) {
+            reCreateNoteTableTriggers(db);
+            reCreateDataTableTriggers(db);
+        }
+
+        // 如果旧版本号与新版本号不一致，则抛出异常
+        if (oldVersion != newVersion) {
+            throw new IllegalStateException("Upgrade notes database to version " + newVersion + " fails");
+        }
+    }
+
+    // 升级到版本2的操作
+    private void upgradeToV2(SQLiteDatabase db) {
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE); // 删除旧的笔记表
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA); // 删除旧的数据表
+        createNoteTable(db); // 创建新的笔记表
+        createDataTable(db); // 创建新的数据表
+    }
+
+    // 升级到版本3的操作
+    private void upgradeToV3(SQLiteDatabase db) {
+        // 删除未使用的触发器
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
+        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
+
+        // 在笔记表中添加一个用于Google任务的ID字段
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+                + " TEXT NOT NULL DEFAULT ''");
+
+        // 插入一个回收站系统文件夹
+        ContentValues values = new ContentValues();
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); // 设置笔记ID为回收站文件夹ID
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置笔记类型为系统类型
+        db.insert(TABLE.NOTE, null, values); // 插入数据到笔记表
+    }
+
+    // 升级到版本4的操作
+    private void upgradeToV4(SQLiteDatabase db) {
+        // 在笔记表中添加一个用于版本号的字段
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+                + " INTEGER NOT NULL DEFAULT 0");
+    }
+}

src/data/NotesProvider.java

@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ppackage net.micode.notes.data;
+
+import android.app.SearchManager; // 搜索管理器
+import android.content.ContentProvider; // 内容提供者
+import android.content.ContentUris; // 处理Uri的工具类
+import android.content.ContentValues; // 内容值，用于插入或更新数据
+import android.content.Intent; // 意图，用于启动活动或发送广播
+import android.content.UriMatcher; // URI匹配器，用于匹配Uri
+import android.database.Cursor; // 数据库游标，用于遍历查询结果
+import android.database.sqlite.SQLiteDatabase; // SQLite数据库
+import android.net.Uri; // 统一资源标识符
+import android.text.TextUtils; // 处理字符串的工具类
+import android.util.Log; // 日志工具类
+
+import net.micode.notes.R; // 资源文件
+import net.micode.notes.data.Notes.DataColumns; // 数据表的列定义
+import net.micode.notes.data.Notes.NoteColumns; // 笔记表的列定义
+import net.micode.notes.data.NotesDatabaseHelper.TABLE; // 数据库表定义
+
+// 定义一个内容提供者，用于管理和查询应用的笔记和数据
+public class NotesProvider extends ContentProvider {
+    // URI匹配器，用于匹配不同的Uri
+    private static final UriMatcher mMatcher;
+
+    // 数据库帮助类实例
+    private NotesDatabaseHelper mHelper;
+
+    // 日志标签
+    private static final String TAG = "NotesProvider";
+
+    // 定义不同的Uri匹配码
+    private static final int URI_NOTE            = 1; // 笔记列表Uri
+    private static final int URI_NOTE_ITEM       = 2; // 单个笔记Uri
+    private static final int URI_DATA            = 3; // 数据列表Uri
+    private static final int URI_DATA_ITEM       = 4; // 单个数据Uri
+    private static final int URI_SEARCH          = 5; // 搜索Uri
+    private static final int URI_SEARCH_SUGGEST  = 6; // 搜索建议Uri
+
+    // 初始化UriMatcher
+    static {
+        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE); // 笔记列表Uri
+        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM); // 单个笔记Uri
+        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA); // 数据列表Uri
+        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM); // 单个数据Uri
+        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH); // 搜索Uri
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST); // 搜索建议Uri路径查询
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST); // 搜索建议Uri路径查询带参数
+    }
+
+    // 定义搜索结果的投影
+    private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + "," // 笔记ID
+        + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + "," // 搜索结果的intent额外数据
+        + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + "," // 笔记摘要，替换换行符并去除前后空白
+        + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + "," // 笔记摘要，替换换行符并去除前后空白
+        + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + "," // 搜索结果的图标
+        + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + "," // 搜索结果的intent动作
+        + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA; // 搜索结果的intent数据
+
+    // 定义笔记摘要搜索查询SQL语句
+    private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+        + " FROM " + TABLE.NOTE
+        + " WHERE " + NoteColumns.SNIPPET + " LIKE ?" // 笔记摘要模糊匹配搜索字符串
+        + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER // 排除回收站中的笔记
+        + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE; // 仅匹配笔记类型的记录
+
+    // 初始化内容提供者
+    @Override
+    public boolean onCreate() {
+        mHelper = NotesDatabaseHelper.getInstance(getContext()); // 获取数据库帮助类实例
+        return true; // 返回true表示成功初始化
+    }
+
+    // 查询数据方法，根据Uri返回相应的数据
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+            String sortOrder) {
+        Cursor c = null; // 游标初始化为null
+        SQLiteDatabase db = mHelper.getReadableDatabase(); // 获取可读的数据库实例
+        String id = null; // 笔记或数据ID初始化为null
+
+        // 根据Uri匹配码执行相应的查询操作
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null, sortOrder); // 查询笔记表
+                break;
+            case URI_NOTE_ITEM:
+                id = uri.getPathSegments().get(1); // 获取Uri路径中的第二个部分作为笔记ID
+                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id + parseSelection(selection), // 根据笔记ID查询
+                        selectionArgs, null, null, sortOrder);
+                break;
+            case URI_DATA:
+                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null, sortOrder); // 查询数据表
+                break;
+            case URI_DATA_ITEM:
+                id = uri.getPathSegments().get(1); // 获取Uri路径中的第二个部分作为数据ID
+                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id + parseSelection(selection), // 根据数据ID查询
+                        selectionArgs, null, null, sortOrder);
+                break;
+            case URI_SEARCH:
+            case URI_SEARCH_SUGGEST:
+                if (sortOrder != null || projection != null) {
+                    throw new IllegalArgumentException("do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
+                }
+
+                String searchString = null; // 搜索字符串初始化为null
+                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
+                    if (uri.getPathSegments().size() > 1) {
+                        searchString = uri.getPathSegments().get(1); // 获取Uri路径中的第二个部分作为搜索字符串
+                    }
+                } else {
+                    searchString = uri.getQueryParameter("pattern"); // 从Uri查询参数中获取搜索字符串
+                }
+
+                if (TextUtils.isEmpty(searchString)) {
+                    return null; // 如果搜索字符串为空，返回null
+                }
+
+                try {
+                    searchString = String.format("%%%s%%", searchString); // 格式化搜索字符串，添加前后通配符
+                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, new String[] { searchString }); // 执行搜索查询
+                } catch (IllegalStateException ex) {
+                    Log.e(TAG, "got exception: " + ex.toString()); // 捕获异常并输出日志
+                }
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri); // 如果Uri不匹配，抛出异常
+        }
+        if (c != null) {
+            c.setNotificationUri(getContext().getContentResolver(), uri); // 设置通知Uri
+        }
+        return c; // 返回查询结果游标
+    }
+
+    // 插入数据方法，根据Uri插入相应的数据
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写的数据库实例
+        long dataId = 0, noteId = 0, insertedId = 0; // 笔记ID、数据ID、插入ID初始化为0
+
+        // 根据Uri匹配码执行相应的插入操作
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                insertedId = noteId = db.insert(TABLE.NOTE, null, values); // 插入笔记数据
+                break;
+            case URI_DATA:
+                if (values.containsKey(DataColumns.NOTE_ID)) {
+                    noteId = values.getAsLong(DataColumns.NOTE_ID); // 获取关联的笔记ID
+                } else {
+                    Log.d(TAG, "Wrong data format without note id:" + values.toString()); // 如果数据格式错误，输出日志
+                }
+                insertedId = dataId = db.insert(TABLE.DATA, null, values); // 插入数据
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri); // 如果Uri不匹配，抛出异常
+        }
+
+        // 通知笔记Uri
+        if (noteId > 0) {
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
+        }
+
+        // 通知数据Uri
+        if (dataId > 0) {
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
+        }
+
+        return ContentUris.withAppendedId(uri, insertedId); // 返回插入数据的Uri
+    }
+
+    // 删除数据方法，根据Uri删除相应的数据
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        int count = 0; // 删除的记录数初始化为0
+        String id = null; // 笔记或数据ID初始化为null
+        SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写的数据库实例
+        boolean deleteData = false; // 标记是否删除数据
+
+        // 根据Uri匹配码执行相应的删除操作
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 "; // 确保ID大于0
+                count = db.delete(TABLE.NOTE, selection, selectionArgs); // 删除笔记数据
+                break;
+            case URI_NOTE_ITEM:
+                id = uri.getPathSegments().get(1); // 获取Uri路径中的第二个部分作为笔记ID
+                long noteId = Long.valueOf(id); // 将笔记ID转换为长整型
+                if (noteId <= 0) {
+                    break; // 如果笔记ID小于等于0，不执行删除操作
+                }
+                count = db.delete(TABLE.NOTE, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); // 根据笔记ID删除笔记数据
+                break;
+            case URI_DATA:
+                count = db.delete(TABLE.DATA, selection, selectionArgs); // 删除数据
+                deleteData = true; // 标记删除数据
+                break;
+            case URI_DATA_ITEM:
+                id = uri.getPathSegments().get(1); // 获取Uri路径中的第二个部分作为数据ID
+                count = db.delete(TABLE.DATA, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); // 根据数据ID删除数据
+                deleteData = true; // 标记删除数据
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri); // 如果Uri不匹配，抛出异常
+        }
+
+        // 如果删除的记录数大于0，则通知相应的Uri
+        if (count > 0) {
+            if (deleteData) {
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); // 通知笔记Uri
+            }
+            getContext().getContentResolver().notifyChange(uri, null); // 通知指定的Uri
+        }
+
+        return count; // 返回删除的记录数
+    }
+
+    // 更新数据方法，根据Uri更新相应的数据
+    @Override
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+        int count = 0; // 更新的记录数初始化为0
+        String id = null; // 笔记或数据ID初始化为null
+        SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写的数据库实例
+        boolean updateData = false; // 标记是否更新数据
+
+        // 根据Uri匹配码执行相应的更新操作
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                increaseNoteVersion(-1, selection, selectionArgs); // 增加笔记版本号
+                count = db.update(TABLE.NOTE, values, selection, selectionArgs); // 更新笔记数据
+                break;
+            case URI_NOTE_ITEM:
+                id = uri.getPathSegments().get(1); // 获取Uri路径中的第二个部分作为笔记ID
+                long noteId = Long.valueOf(id); // 将笔记ID转换为长整型
+                increaseNoteVersion(noteId, selection, selectionArgs); // 增加笔记版本号
+                count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); // 根据笔记ID更新笔记数据
+                break;
+            case URI_DATA:
+                count = db.update(TABLE.DATA, values, selection, selectionArgs); // 更新数据
+                updateData = true; // 标记更新数据
+                break;
+            case URI_DATA_ITEM:
+                id = uri.getPathSegments().get(1); // 获取Uri路径中的第二个部分作为数据ID
+                count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); // 根据数据ID更新数据
+                updateData = true; // 标记更新数据
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri); // 如果Uri不匹配，抛出异常
+        }
+
+        // 如果更新的记录数大于0，则通知相应的Uri
+        if (count > 0) {
+            if (updateData) {
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); // 通知笔记Uri
+            }
+            getContext().getContentResolver().notifyChange(uri, null); // 通知指定的Uri
+        }
+
+        return count; // 返回更新的记录数
+    }
+
+    // 解析查询条件，如果selection不为空，则在前面添加AND关键字
+    private String parseSelection(String selection) {
+        return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
+    }
+
+    // 增加笔记版本号的方法
+    private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+        StringBuilder sql = new StringBuilder(120); // 构建SQL语句
+        sql.append("UPDATE "); // 更新操作
+        sql.append(TABLE.NOTE);
+        sql.append(" SET ");
+        sql.append(NoteColumns.VERSION);
+        sql.append("=" + NoteColumns.VERSION + "+1 "); // 版本号加1
+
+        // 如果id大于0或selection不为空，则添加WHERE关键字
+        if (id > 0 || !TextUtils.isEmpty(selection)) {
+            sql.append(" WHERE ");
+        }
+        if (id > 0) {
+            sql.append(NoteColumns.ID + "=" + String.valueOf(id)); // 根据笔记ID更新
+        }
+        if (!TextUtils.isEmpty(selection)) {
+            String selectString = id > 0 ? parseSelection(selection) : selection; // 解析查询条件
+            for (String args : selectionArgs) {
+                selectString = selectString.replaceFirst("\\?", args); // 替换查询条件中的占位符
+            }
+            sql.append(selectString);
+        }
+
+        mHelper.getWritableDatabase().execSQL(sql.toString()); // 执行SQL语句
+    }
+
+    // 获取Uri对应的MIME类型
+    @Override
+    public String getType(Uri uri) {
+        // TODO Auto-generated method stub
+        return null; // 返回null，表示不实现该方法
+    }
+
+}

src/model/Note.java

@@ -0,0 +1,356 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.model;
+
+// 导入Android内容提供者操作和结果相关的类
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.OperationApplicationException;
+import android.net.Uri;
+import android.os.RemoteException;
+import android.util.Log;
+
+// 导入Notes应用的数据模型相关的类
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+
+// 导入ArrayList类，用于存储ContentProvider操作
+import java.util.ArrayList;
+
+// 定义Note类，用于表示一个笔记及其关联的数据。。
+public class Note {
+    // 成员变量mNoteDiffValues用于存储笔记的键值对，表示笔记内容的差异
+    private ContentValues mNoteDiffValues;
+    // 成员变量mNoteData用于存储笔记的文本和通话数据
+    private NoteData mNoteData;
+    // 常量TAG用于在日志中标识Note类的日志信息
+    private static final String TAG = "Note";
+
+    /**
+     * 创建一个新的笔记ID，用于添加新的笔记到数据库
+     */
+    public static synchronized long getNewNoteId(Context context, long folderId) {
+        // 创建一个新的ContentValues对象values，用于存储笔记的键值对
+        ContentValues values = new ContentValues();
+        // 获取当前时间戳，并将其作为笔记的创建和修改日期
+        long createdTime = System.currentTimeMillis();
+        values.put(NoteColumns.CREATED_DATE, createdTime);
+        values.put(NoteColumns.MODIFIED_DATE, createdTime);
+        // 设置笔记类型为普通笔记
+        values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+        // 标记笔记为已本地修改
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        // 设置笔记的父文件夹ID
+        values.put(NoteColumns.PARENT_ID, folderId);
+        // 向Notes.CONTENT_NOTE_URI插入新的笔记，并获取返回的Uri
+        Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
+
+        long noteId = 0;
+        try {
+            // 从Uri中提取笔记ID
+            noteId = Long.valueOf(uri.getPathSegments().get(1));
+        } catch (NumberFormatException e) {
+            // 如果提取笔记ID失败，记录错误日志
+            Log.e(TAG, "Get note id error :" + e.toString());
+            noteId = 0;
+        }
+        if (noteId == -1) {
+            // 如果笔记ID为-1，抛出异常
+            throw new IllegalStateException("Wrong note id:" + noteId);
+        }
+        // 返回新创建的笔记ID
+        return noteId;
+    }
+
+    // 构造函数Note，初始化mNoteDiffValues和mNoteData对象
+    public Note() {
+        mNoteDiffValues = new ContentValues(); // 初始化笔记差异值
+        mNoteData = new NoteData(); // 初始化笔记数据
+    }
+
+    // 方法setNoteValue，设置笔记的键值对，并标记笔记为已修改
+    // 参数key为键名，value为键对应的值
+    public void setNoteValue(String key, String value) {
+        // 将键值对存储到mNoteDiffValues中
+        mNoteDiffValues.put(key, value);
+        // 标记笔记为已本地修改
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+        // 更新笔记的修改日期为当前时间
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+    }
+
+    // 方法setTextData，设置文本数据的键值对，并调用NoteData中的方法进行处理
+    // 参数key为键名，value为键对应的值
+    public void setTextData(String key, String value) {
+        mNoteData.setTextData(key, value); // 调用NoteData类的方法设置文本数据
+    }
+
+    // 方法setTextDataId，设置文本数据在数据库中的ID
+    // 参数id为文本数据的ID
+    public void setTextDataId(long id) {
+        mNoteData.setTextDataId(id); // 调用NoteData类的方法设置文本数据ID
+    }
+
+    // 方法getTextDataId，获取文本数据在数据库中的ID
+    public long getTextDataId() {
+        return mNoteData.mTextDataId; // 返回文本数据ID
+    }
+
+    // 方法setCallDataId，设置通话数据在数据库中的ID
+    // 参数id为通话数据的ID
+    public void setCallDataId(long id) {
+        mNoteData.setCallDataId(id); // 调用NoteData类的方法设置通话数据ID
+    }
+
+    // 方法setCallData，设置通话数据的键值对，并调用NoteData中的方法进行处理
+    // 参数key为键名，value为键对应的值
+    public void setCallData(String key, String value) {
+        mNoteData.setCallData(key, value); // 调用NoteData类的方法设置通话数据
+    }
+
+    // 方法isLocalModified，检查笔记是否被本地修改过
+    // 如果mNoteDiffValues或mNoteData中包含键值对，则返回true，否则返回false
+    public boolean isLocalModified() {
+        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified(); // 检查是否需要更新
+    }
+
+    // 方法syncNote，将本地修改的笔记同步到数据库
+    // 参数context为上下文对象，noteId为笔记的ID
+    public boolean syncNote(Context context, long noteId) {
+        // 检查笔记ID是否有效（大于0），无效则抛出IllegalArgumentException异常
+        if (noteId <= 0) {
+            throw new IllegalArgumentException("错误的笔记ID: " + noteId); // 如果笔记ID不合法，抛出异常
+        }
+
+        // 如果笔记没有被本地修改，则直接返回true
+        if (!isLocalModified()) {
+            return true; // 如果没有本地修改，直接返回true
+        }
+
+        /**
+         * 理论上，一旦数据发生变化，笔记应该在{@link NoteColumns#LOCAL_MODIFIED}和
+         * {@link NoteColumns#MODIFIED_DATE}上进行更新。为了数据安全，即使更新笔记失败，我们也会更新
+         * 笔记数据信息
+         */
+        // 更新笔记内容到数据库，如果更新失败，记录错误日志但不返回
+        if (context.getContentResolver().update(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null, // 更新笔记信息
+                null) == 0) {
+            Log.e(TAG, "Update note error, should not happen");
+            // 不返回，继续执行
+        }
+        // 清空mNoteDiffValues，准备下一次修改
+        mNoteDiffValues.clear();
+
+        // 如果NoteData中有本地修改，则尝试将其推送到ContentResolver中
+        // 如果推送失败，则返回false
+        if (mNoteData.isLocalModified()
+                && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
+            return false; // 如果推送失败，返回false
+        }
+
+        // 如果所有操作成功，则返回true
+        return true;
+    }
+
+    // 定义一个私有的内部类NoteData，用于处理笔记中的文本和通话数据
+    private class NoteData {
+        // 成员变量mTextDataId用于存储文本数据在数据库中的ID
+        private long mTextDataId;
+
+        // 成员变量mTextDataValues用于存储文本数据的键值对
+        private ContentValues mTextDataValues;
+
+        // 成员变量mCallDataId用于存储通话数据在数据库中的ID
+        private long mCallDataId;
+
+        // 成员变量mCallDataValues用于存储通话数据的键值对
+        private ContentValues mCallDataValues;
+
+        // 常量TAG用于在日志中标识NoteData类的日志信息
+        private static final String TAG = "NoteData";
+
+        // 构造函数NoteData，初始化mTextDataValues和mCallDataValues对象，并将mTextDataId和mCallDataId设置为0
+        public NoteData() {
+            mTextDataValues = new ContentValues(); // 初始化文本数据
+            mCallDataValues = new ContentValues(); // 初始化通话数据
+            mTextDataId = 0; // 设置初始文本数据ID为0
+            mCallDataId = 0; // 设置初始通话数据ID为0
+        }
+
+        // 方法isLocalModified，检查文本数据或通话数据是否被本地修改过
+        // 如果mTextDataValues或mCallDataValues中包含键值对，则返回true，否则返回false
+        boolean isLocalModified() {
+            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0; // 检查是否有差异值
+        }
+
+        // 方法setTextDataId，设置文本数据在数据库中的ID
+        // 参数id为文本数据的ID
+        // 如果传入的ID小于等于0，则抛出IllegalArgumentException异常
+        void setTextDataId(long id) {
+            if(id <= 0) {
+                throw new IllegalArgumentException("文本数据ID应大于0"); // 如果ID不合法，抛出异常
+            }
+            mTextDataId = id; // 设置文本数据ID
+        }
+
+        // 方法setCallDataId，设置通话数据在数据库中的ID
+        // 参数id为通话数据的ID
+        // 如果传入的ID小于等于0，则抛出IllegalArgumentException异常
+        void setCallDataId(long id) {
+            if (id <= 0) {
+                throw new IllegalArgumentException("通话数据ID应大于0"); // 如果ID不合法，抛出异常
+            }
+            mCallDataId = id; // 设置通话数据ID
+        }
+
+        // 方法setCallData，设置通话数据的键值对，并标记笔记为已修改
+        // 参数key为键名，value为键对应的值
+        void setCallData(String key, String value) {
+            // 将键值对存储到mCallDataValues中
+            mCallDataValues.put(key, value);
+            // 标记笔记为已本地修改
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+            // 更新笔记的修改日期为当前时间
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        }
+
+        // 方法setTextData，设置文本数据的键值对，并标记笔记为已修改
+        // 参数key为键名，value为键对应的值
+        void setTextData(String key, String value) {
+            // 将键值对存储到mTextDataValues中
+            mTextDataValues.put(key, value);
+            // 标记笔记为已本地修改
+            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+            // 更新笔记的修改日期为当前时间
+            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+        }
+
+        // 方法pushIntoContentResolver，将本地修改的数据推送到ContentResolver中
+        // 参数context为上下文对象，noteId为笔记的ID
+        Uri pushIntoContentResolver(Context context, long noteId) {
+            /**
+             * 检查数据安全性
+             */
+            // 检查笔记ID是否有效（大于0），无效则抛出IllegalArgumentException异常
+            if (noteId <= 0) {
+                throw new IllegalArgumentException("错误的笔记ID: " + noteId); // 如果笔记ID不合法，抛出异常
+            }
+
+            // 创建一个ContentProviderOperation列表operationList，用于存储ContentProvider操作
+            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+            // 定义一个ContentProviderOperation.Builder对象builder，用于构建ContentProvider操作
+            ContentProviderOperation.Builder builder = null;
+
+            // 检查mTextDataValues是否包含键值对
+            if(mTextDataValues.size() > 0) {
+                // 将noteId添加到mTextDataValues中，作为文本数据的关联笔记ID
+                mTextDataValues.put(DataColumns.NOTE_ID, noteId);
+                // 如果mTextDataId为0，表示这是新的文本数据，需要插入到数据库
+                if (mTextDataId == 0) {
+                    // 设置数据类型为文本笔记
+                    mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
+                    // 向Notes.CONTENT_DATA_URI插入新的文本数据，并获取返回的Uri
+                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                            mTextDataValues);
+                    try {
+                        // 从Uri中提取文本数据ID，并设置到mTextDataId中
+                        setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        // 如果提取文本数据ID失败，记录错误日志并清空mTextDataValues
+                        Log.e(TAG, "Insert new text data fail with noteId" + noteId);
+                        mTextDataValues.clear();
+                        return null;
+                    }
+                } else {
+                    // 如果mTextDataId不为0，表示这是已存在的文本数据，需要更新
+                    // 使用ContentProviderOperation.Builder构建更新操作
+                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mTextDataId));
+                    // 设置更新的键值对
+                    builder.withValues(mTextDataValues);
+                    // 将构建的更新操作添加到operationList中
+                    operationList.add(builder.build());
+                }
+                // 清空mTextDataValues，准备下一次修改
+                mTextDataValues.clear();
+            }
+
+            // 检查mCallDataValues是否包含键值对
+            if(mCallDataValues.size() > 0) {
+                // 将noteId添加到mCallDataValues中，作为通话数据的关联笔记ID
+                mCallDataValues.put(DataColumns.NOTE_ID, noteId);
+                // 如果mCallDataId为0，表示这是新的通话数据，需要插入到数据库
+                if (mCallDataId == 0) {
+                    // 设置数据类型为通话笔记
+                    mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
+                    // 向Notes.CONTENT_DATA_URI插入新的通话数据，并获取返回的Uri
+                    Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                            mCallDataValues);
+                    try {
+                        // 从Uri中提取通话数据ID，并设置到mCallDataId中
+                        setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
+                    } catch (NumberFormatException e) {
+                        // 如果提取通话数据ID失败，记录错误日志并清空mCallDataValues
+                        Log.e(TAG, "Insert new call data fail with noteId" + noteId);
+                        mCallDataValues.clear();
+                        return null;
+                    }
+                } else {
+                    // 如果mCallDataId不为0，表示这是已存在的通话数据，需要更新
+                    // 使用ContentProviderOperation.Builder构建更新操作
+                    builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mCallDataId));
+                    // 设置更新的键值对
+                    builder.withValues(mCallDataValues);
+                    // 将构建的更新操作添加到operationList中
+                    operationList.add(builder.build());
+                }
+                // 清空mCallDataValues，准备下一次修改
+                mCallDataValues.clear();
+            }
+
+            // 如果operationList中有待执行的操作，则应用这些操作到ContentResolver中
+            if (operationList.size() > 0) {
+                try {
+                    // 应用批处理操作，并获取结果
+                    ContentProviderResult[] results = context.getContentResolver().applyBatch(
+                            Notes.AUTHORITY, operationList);
+                    // 如果结果为空或长度为0，或者第一个结果为空，则返回null
+                    return (results == null || results.length == 0 || results[0] == null) ? null
+                            : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId); // 返回结果URI
+                } catch (RemoteException e) {
+                    // 如果远程操作失败，记录错误日志并返回null
+                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+                    return null;
+                } catch (OperationApplicationException e) {
+                    // 如果操作应用失败，记录错误日志并返回null
+                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+                    return null;
+                }
+            }
+            // 如果没有操作需要执行，返回null
+            return null;
+        }
+    }
+}

src/model/WorkingNote.java

@@ -0,0 +1,516 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * 许可证声明部分
+ * （此处省略许可证声明的具体内容）
+ */
+
+package net.micode.notes.model;
+
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.text.TextUtils;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.tool.ResourceParser.NoteBgResources;
+
+/**
+ * WorkingNote类用于管理笔记的操作，包括创建、加载、保存和修改笔记。。。
+ */
+public class WorkingNote {
+    // 笔记对象
+    private Note mNote;
+    // 笔记的唯一标识符
+    private long mNoteId;
+    // 笔记的内容
+    private String mContent;
+    // 笔记的模式
+    private int mMode;
+
+    // 笔记的提醒日期
+    private long mAlertDate;
+
+    // 笔记的最后修改日期
+    private long mModifiedDate;
+
+    // 笔记的背景颜色ID
+    private int mBgColorId;
+
+    // 笔记关联的小部件ID
+    private int mWidgetId;
+
+    // 笔记关联的小部件类型
+    private int mWidgetType;
+
+    // 笔记所在的文件夹ID
+    private long mFolderId;
+
+    // 上下文对象
+    private Context mContext;
+
+    // 日志标签
+    private static final String TAG = "WorkingNote";
+
+    // 笔记是否被删除的标志
+    private boolean mIsDeleted;
+
+    // 笔记设置状态变化监听器
+    private NoteSettingChangedListener mNoteSettingStatusListener;
+
+    // 数据查询字段集
+    public static final String[] DATA_PROJECTION = new String[] {
+            DataColumns.ID,
+            DataColumns.CONTENT,
+            DataColumns.MIME_TYPE,
+            DataColumns.DATA1,
+            DataColumns.DATA2,
+            DataColumns.DATA3,
+            DataColumns.DATA4,
+    };
+
+    // 笔记查询字段集
+    public static final String[] NOTE_PROJECTION = new String[] {
+            NoteColumns.PARENT_ID,
+            NoteColumns.ALERTED_DATE,
+            NoteColumns.BG_COLOR_ID,
+            NoteColumns.WIDGET_ID,
+            NoteColumns.WIDGET_TYPE,
+            NoteColumns.MODIFIED_DATE
+    };
+
+    // 数据查询字段索引
+    private static final int DATA_ID_COLUMN = 0;
+    private static final int DATA_CONTENT_COLUMN = 1;
+    private static final int DATA_MIME_TYPE_COLUMN = 2;
+    private static final int DATA_MODE_COLUMN = 3;
+
+    // 笔记查询字段索引
+    private static final int NOTE_PARENT_ID_COLUMN = 0;
+    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
+    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
+    private static final int NOTE_WIDGET_ID_COLUMN = 3;
+    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
+    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
+
+    /**
+     * 创建一个新的WorkingNote对象，用于表示一个新的笔记
+     * @param context 上下文对象
+     * @param folderId 笔记所在的文件夹ID
+     */
+    private WorkingNote(Context context, long folderId) {
+        mContext = context;
+        mAlertDate = 0; // 初始化提醒日期为0
+        mModifiedDate = System.currentTimeMillis(); // 初始化修改时间为当前时间戳
+        mFolderId = folderId; // 设置笔记所在的文件夹ID
+        mNote = new Note(); // 创建一个Note对象
+        mNoteId = 0; // 初始化笔记ID为0
+        mIsDeleted = false; // 初始化为未删除
+        mMode = 0; // 初始化笔记模式为0
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 初始化小部件类型为无效
+    }
+
+    /**
+     * 从数据库中加载一个已存在的笔记对象
+     * @param context 上下文对象
+     * @param noteId 笔记的唯一标识符
+     * @param folderId 笔记所在的文件夹ID
+     */
+    private WorkingNote(Context context, long noteId, long folderId) {
+        mContext = context;
+        mNoteId = noteId; // 设置笔记ID
+        mFolderId = folderId; // 设置笔记所在的文件夹ID
+        mIsDeleted = false; // 初始化为未删除
+        mNote = new Note(); // 创建一个Note对象
+        loadNote(); // 加载笔记信息
+    }
+
+    /**
+     * 从数据库中加载笔记的基本信息
+     */
+    private void loadNote() {
+        Cursor cursor = mContext.getContentResolver().query(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
+                null, null); // 查询笔记信息
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN); // 获取文件夹ID
+                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN); // 获取背景颜色ID
+                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN); // 获取小部件ID
+                mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN); // 获取小部件类型
+                mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN); // 获取提醒日期
+                mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN); // 获取修改日期
+            }
+            cursor.close(); // 关闭游标
+        } else {
+            Log.e(TAG, "没有ID为:" + mNoteId + "的笔记"); // 记录错误
+            throw new IllegalArgumentException("无法找到ID为 " + mNoteId + " 的笔记"); // 抛出异常
+        }
+        loadNoteData(); // 加载笔记数据
+    }
+
+    /**
+     * 从数据库中加载笔记的具体内容
+     */
+    private void loadNoteData() {
+        Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
+                DataColumns.NOTE_ID + "=?", new String[] {
+                    String.valueOf(mNoteId)
+                }, null); // 查询笔记数据
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                do {
+                    String type = cursor.getString(DATA_MIME_TYPE_COLUMN); // 获取数据类型
+                    if (DataConstants.NOTE.equals(type)) { // 如果是普通笔记数据
+                        mContent = cursor.getString(DATA_CONTENT_COLUMN); // 获取笔记内容
+                        mMode = cursor.getInt(DATA_MODE_COLUMN); // 获取笔记模式
+                        mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN)); // 设置文本数据ID
+                    } else if (DataConstants.CALL_NOTE.equals(type)) { // 如果是通话笔记数据
+                        mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN)); // 设置通话数据ID
+                    } else {
+                        Log.d(TAG, "错误的笔记类型:" + type); // 记录错误的笔记类型
+                    }
+                } while (cursor.moveToNext());
+            }
+            cursor.close(); // 关闭游标
+        } else {
+            Log.e(TAG, "没有ID为:" + mNoteId + "的数据"); // 记录错误
+            throw new IllegalArgumentException("无法找到ID为 " + mNoteId + " 的笔记数据"); // 抛出异常
+        }
+    }
+
+    /**
+     * 创建一个新的空笔记对象
+     * @param context 上下文对象
+     * @param folderId 笔记所在的文件夹ID
+     * @param widgetId 笔记关联的小部件ID
+     * @param widgetType 笔记关联的小部件类型
+     * @param defaultBgColorId 笔记的默认背景颜色ID
+     * @return 新创建的WorkingNote对象
+     */
+    public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
+            int widgetType, int defaultBgColorId) {
+        WorkingNote note = new WorkingNote(context, folderId); // 创建新笔记
+        note.setBgColorId(defaultBgColorId); // 设置背景颜色ID
+        note.setWidgetId(widgetId); // 设置小部件ID
+        note.setWidgetType(widgetType); // 设置小部件类型
+        return note; // 返回新创建的笔记对象
+    }
+
+    /**
+     * 从数据库中加载一个已存在的笔记对象
+     * @param context 上下文对象
+     * @param id 笔记的唯一标识符
+     * @return 加载的WorkingNote对象
+     */
+    public static WorkingNote load(Context context, long id) {
+        return new WorkingNote(context, id, 0); // 加载已存在的笔记
+    }
+
+    /**
+     * 保存笔记到数据库
+     * @return 成功保存返回true，否则返回false
+     */
+    public synchronized boolean saveNote() {
+        if (isWorthSaving()) { // 如果值得保存
+            if (!existInDatabase()) { // 如果笔记不在数据库中
+                if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) { // 创建新的笔记ID
+                    Log.e(TAG, "创建新的笔记失败，ID:" + mNoteId); // 记录错误
+                    return false; // 返回false，表示保存失败
+                }
+            }
+
+            mNote.syncNote(mContext, mNoteId); // 同步笔记到数据库
+
+            /**
+             * 如果笔记关联了小部件，则更新小部件的内容
+             */
+            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
+                    && mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onWidgetChanged(); // 通知小部件内容变化
+            }
+            return true; // 返回true，表示保存成功
+        } else {
+            return false; // 返回false，表示不值得保存
+        }
+    }
+
+    /**
+     * 检查笔记是否存在于数据库中
+     * @return 存在于数据库中返回true，否则返回false
+     */
+    public boolean existInDatabase() {
+        return mNoteId > 0; // 笔记ID大于0表示存在
+    }
+
+    /**
+     * 判断当前笔记是否需要保存
+     * @return 需要保存返回true，否则返回false
+     */
+    private boolean isWorthSaving() {
+        if (mIsDeleted || // 如果笔记已删除
+                (!existInDatabase() && TextUtils.isEmpty(mContent)) // 如果笔记不在数据库中且内容为空
+                || (existInDatabase() && !mNote.isLocalModified())) { // 如果笔记在数据库中且没有本地修改
+            return false; // 返回false，表示不值得保存
+        } else {
+            return true; // 返回true，表示值得保存
+        }
+    }
+
+    /**
+     * 设置笔记设置状态变化监听器
+     * @param l 笔记设置状态变化监听器
+     */
+    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
+        mNoteSettingStatusListener = l; // 设置监听器
+    }
+
+    /**
+     * 设置笔记的提醒日期
+     * @param date 提醒日期
+     * @param set 是否设置了提醒
+     */
+    public void setAlertDate(long date, boolean set) {
+        if (date != mAlertDate) { // 如果提醒日期发生变化
+            mAlertDate = date; // 更新提醒日期
+            mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate)); // 设置提醒日期到Note对象
+        }
+        if (mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onClockAlertChanged(date, set); // 通知监听器提醒日期变化
+        }
+    }
+
+    /**
+     * 标记笔记是否被删除
+     * @param mark 是否被删除
+     */
+    public void markDeleted(boolean mark) {
+        mIsDeleted = mark; // 更新删除状态
+        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID // 如果小部件ID有效
+                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE // 如果小部件类型有效
+                && mNoteSettingStatusListener != null) { // 如果监听器不为空
+                mNoteSettingStatusListener.onWidgetChanged(); // 通知监听器小部件内容变化
+        }
+    }
+
+    /**
+     * 设置笔记的背景颜色ID
+     * @param id 背景颜色ID
+     */
+    public void setBgColorId(int id) {
+        if (id != mBgColorId) { // 如果背景颜色ID发生变化
+            mBgColorId = id; // 更新背景颜色ID
+            if (mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onBackgroundColorChanged(); // 通知监听器背景颜色变化
+            }
+            mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id)); // 设置背景颜色ID到Note对象
+        }
+    }
+
+    /**
+     * 设置笔记的检查列表模式
+     * @param mode 检查列表模式
+     */
+    public void setCheckListMode(int mode) {
+        if (mMode != mode) { // 如果模式发生变化
+            if (mNoteSettingStatusListener != null) {
+                mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode); // 通知监听器模式变化
+            }
+            mMode = mode; // 更新模式
+            mNote.setTextData(TextNote.MODE, String.valueOf(mMode)); // 设置模式到Note对象
+        }
+    }
+
+    /**
+     * 设置笔记关联的小部件类型
+     * @param type 小部件类型
+     */
+    public void setWidgetType(int type) {
+        if (type != mWidgetType) { // 如果小部件类型发生变化
+            mWidgetType = type; // 更新小部件类型
+            mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType)); // 设置小部件类型到Note对象
+        }
+    }
+
+    /**
+     * 设置笔记关联的小部件ID
+     * @param id 小部件ID
+     */
+    public void setWidgetId(int id) {
+        if (id != mWidgetId) { // 如果小部件ID发生变化
+            mWidgetId = id; // 更新小部件ID
+            mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId)); // 设置小部件ID到Note对象
+        }
+    }
+
+    /**
+     * 设置笔记的内容文本
+     * @param text 笔记内容
+     */
+    public void setWorkingText(String text) {
+        if (!TextUtils.equals(mContent, text)) { // 如果内容发生变化
+            mContent = text; // 更新内容
+            mNote.setTextData(DataColumns.CONTENT, mContent); // 设置内容到Note对象
+        }
+    }
+
+    /**
+     * 将笔记转换为通话笔记
+     * @param phoneNumber 电话号码
+     * @param callDate 通话日期
+     */
+    public void convertToCallNote(String phoneNumber, long callDate) {
+        mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate)); // 设置通话日期到Note对象
+        mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber); // 设置通话号码到Note对象
+        mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER)); // 设置父文件夹ID为通话记录文件夹
+    }
+
+    /**
+     * 检查笔记是否有提醒设置
+     * @return 有提醒设置返回true，否则返回false
+     */
+    public boolean hasClockAlert() {
+        return mAlertDate > 0;
+    }
+
+    /**
+     * 获取笔记的内容文本
+     * @return 笔记内容
+     */
+    public String getContent() {
+        return mContent; // 返回笔记内容
+    }
+
+    /**
+     * 获取笔记的提醒日期
+     * @return 提醒日期
+     */
+    public long getAlertDate() {
+        return mAlertDate; // 返回提醒日期
+    }
+
+    /**
+     * 获取笔记的最后修改日期
+     * @return 最后修改日期
+     */
+    public long getModifiedDate() {
+        return mModifiedDate; // 返回修改日期
+    }
+
+    /**
+     * 获取笔记的背景颜色资源ID
+     * @return 背景颜色资源ID
+     */
+    public int getBgColorResId() {
+        return NoteBgResources.getNoteBgResource(mBgColorId); // 返回背景颜色资源ID
+    }
+
+    /**
+     * 获取笔记的背景颜色ID
+     * @return 背景颜色ID
+     */
+    public int getBgColorId() {
+        return mBgColorId; // 返回背景颜色ID
+    }
+
+    /**
+     * 获取笔记的标题背景颜色资源ID
+     * @return 标题背景颜色资源ID
+     */
+    public int getTitleBgResId() {
+        return NoteBgResources.getNoteTitleBgResource(mBgColorId); // 返回笔记标题的背景颜色资源ID
+    }
+
+    /**
+     * 获取笔记的检查列表模式
+     * @return 检查列表模式
+     */
+    public int getCheckListMode() {
+        return mMode; // 返回笔记模式
+    }
+
+    /**
+     * 获取笔记的唯一标识符
+     * @return 笔记ID
+     */
+    public long getNoteId() {
+        return mNoteId; // 返回笔记ID
+    }
+
+    /**
+     * 获取笔记所在的文件夹ID
+     * @return 文件夹ID
+     */
+    public long getFolderId() {
+        return mFolderId; // 返回文件夹ID
+    }
+
+    /**
+     * 获取笔记关联的小部件ID
+     * @return 小部件ID
+     */
+    public int getWidgetId() {
+        return mWidgetId; // 返回小部件ID
+    }
+
+    /**
+     * 获取笔记关联的小部件类型
+     * @return 小部件类型
+     */
+    public int getWidgetType() {
+        return mWidgetType; // 返回小部件类型
+    }
+
+    /**
+     * 定义一个接口，用于监听笔记设置的变化
+     */
+    public interface NoteSettingChangedListener {
+        /**
+         * 当笔记的背景颜色发生变化时调用
+         */
+        void onBackgroundColorChanged();
+
+        /**
+         * 当用户设置闹钟时调用
+         * @param date 闹钟时间
+         * @param set 是否设置了闹钟
+         */
+        void onClockAlertChanged(long date, boolean set);
+
+        /**
+         * 当用户通过小部件创建笔记时调用
+         */
+        void onWidgetChanged();
+
+        /**
+         * 当用户在检查列表模式和普通模式之间切换时调用
+         * @param oldMode 切换前的模式
+         * @param newMode 切换后的模式
+         */
+        void onCheckListModeChanged(int oldMode, int newMode);
+    }
+}