Merge pull request '合并代码' (#5) from 赵西林 into main

src/MetaData.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * （版权所有（c）2010 - 2011，MiCode 开源社区（www.micode.net））
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * （根据 Apache License 2.0 版（“许可证”）获得许可；）
+ * 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
+ * （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.gtask.data;
+// 包 net.micode.notes.gtask.data;（包名为 net.micode.notes.gtask.data；）
+
+import android.database.Cursor;
+// 导入 android.database.Cursor；（导入 Android 的数据库游标类；）
+import android.util.Log;
+// 导入 android.util.Log；（导入 Android 的日志工具类；）
+
+import net.micode.notes.tool.GTaskStringUtils;
+// 导入 net.micode.notes.tool.GTaskStringUtils；（导入来自 net.micode.notes.tool 的 GTaskStringUtils 类；）
+
+import org.json.JSONException;
+// 导入 org.json.JSONException；（导入 JSON 处理的异常类；）
+import org.json.JSONObject;
+// 导入 org.json.JSONObject；（导入 JSON 对象类；）
+
+
+public class MetaData extends Task {
+// 公共类 MetaData 继承自 Task；（定义一个名为 MetaData 的公共类，它继承自 Task 类；）
+    private final static String TAG = MetaData.class.getSimpleName();
+// 私有最终静态字符串变量 TAG，赋值为 MetaData 类的简单名称；（定义一个私有最终静态的字符串变量 TAG，值为 MetaData 类的简单名称；）
+
+    private String mRelatedGid = null;
+// 私有字符串变量 mRelatedGid，初始值为 null；（定义一个私有字符串变量 mRelatedGid，初始值为 null；）
+
+    public void setMeta(String gid, JSONObject metaInfo) {
+// 公共方法 setMeta，接收字符串 gid 和 JSON 对象 metaInfo；（定义一个名为 setMeta 的公共方法，接收一个字符串 gid 和一个 JSONObject 对象 metaInfo；）
+        try {
+// 尝试执行以下代码块；（开始 try 代码块；）
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
+// 将 gid 放入 metaInfo 的特定键中；（尝试将 gid 放入 metaInfo 对象中，键为 GTaskStringUtils.META_HEAD_GTASK_ID；）
+        } catch (JSONException e) {
+// 如果发生 JSON 异常，进入此代码块；（捕获 JSONException 异常；）
+            Log.e(TAG, "failed to put related gid");
+// 输出错误日志；（打印错误日志，提示“failed to put related gid”；）
+        }
+        setNotes(metaInfo.toString());
+// 设置 notes 属性；（设置当前对象的 notes 属性为 metaInfo 的字符串表示形式；）
+        setName(GTaskStringUtils.META_NOTE_NAME);
+// 设置 name 属性；（设置当前对象的 name 属性为 GTaskStringUtils.META_NOTE_NAME；）
+    }
+
+    public String getRelatedGid() {
+// 公共方法 getRelatedGid；（定义一个名为 getRelatedGid 的公共方法；）
+        return mRelatedGid;
+// 返回 mRelatedGid；（返回 mRelatedGid 的值；）
+    }
+
+    @Override
+    public boolean isWorthSaving() {
+// 重写方法 isWorthSaving；（重写父类的 isWorthSaving 方法；）
+        return getNotes()!= null;
+// 返回 notes 属性不为 null 的判断结果；（返回当前对象的 notes 属性不为 null 的判断结果；）
+    }
+
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) {
+// 重写方法 setContentByRemoteJSON；（重写父类的 setContentByRemoteJSON 方法；）
+        super.setContentByRemoteJSON(js);
+// 调用父类的同名方法；（先调用父类的 setContentByRemoteJSON 方法；）
+        if (getNotes()!= null) {
+// 如果 notes 属性不为 null；（如果当前对象的 notes 属性不为 null；）
+            try {
+// 尝试执行以下代码块；（开始 try 代码块；）
+                JSONObject metaInfo = new JSONObject(getNotes().trim());
+// 创建一个新的 JSON 对象，从 notes 属性的字符串表示形式中获取；（从当前对象的 notes 属性的字符串表示形式中创建一个新的 JSONObject 对象；）
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
+// 获取相关的 gid；（从新创建的 JSONObject 对象中获取特定键的值，并赋值给 mRelatedGid；）
+            } catch (JSONException e) {
+// 如果发生 JSON 异常，进入此代码块；（捕获 JSONException 异常；）
+                Log.w(TAG, "failed to get related gid");
+// 输出警告日志；（打印警告日志，提示“failed to get related gid”；）
+                mRelatedGid = null;
+// 将 mRelatedGid 设为 null；（将 mRelatedGid 设为 null；）
+            }
+        }
+    }
+
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {
+// 重写方法 setContentByLocalJSON；（重写父类的 setContentByLocalJSON 方法；）
+        // this function should not be called
+// 此函数不应被调用；（注释说明这个函数不应该被调用；）
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
+// 抛出非法访问错误；（抛出 IllegalAccessError 异常，提示“MetaData:setContentByLocalJSON should not be called”；）
+    }
+
+    @Override
+    public JSONObject getLocalJSONFromContent() {
+// 重写方法 getLocalJSONFromContent；（重写父类的 getLocalJSONFromContent 方法；）
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
+// 抛出非法访问错误；（抛出 IllegalAccessError 异常，提示“MetaData:getLocalJSONFromContent should not be called”；）
+    }
+
+    @Override
+    public int getSyncAction(Cursor c) {
+// 重写方法 getSyncAction；（重写父类的 getSyncAction 方法；）
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
+// 抛出非法访问错误；（抛出 IllegalAccessError 异常，提示“MetaData:getSyncAction should not be called”；）
+    }
+
+}

src/Node.java

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * （版权所有（c）2010 - 2011，MiCode 开源社区（www.micode.net））
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * （根据 Apache License 2.0 版（“许可证”）获得许可；）
+ * 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
+ * （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.gtask.data;
+// 包 net.micode.notes.gtask.data;（包名为 net.micode.notes.gtask.data；）
+
+import android.database.Cursor;
+// 导入 android.database.Cursor；（导入 Android 的数据库游标类；）
+
+import org.json.JSONObject;
+// 导入 org.json.JSONObject；（导入 JSON 对象类；）
+
+public abstract class Node {
+// 公共抽象类 Node；（定义一个名为 Node 的公共抽象类；）
+    public static final int SYNC_ACTION_NONE = 0;
+// 公共静态最终整型变量 SYNC_ACTION_NONE，赋值为 0；（定义一个公共静态最终的整型变量 SYNC_ACTION_NONE，值为 0；）
+
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;
+// 公共静态最终整型变量 SYNC_ACTION_ADD_REMOTE，赋值为 1；（定义一个公共静态最终的整型变量 SYNC_ACTION_ADD_REMOTE，值为 1；）
+
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;
+// 公共静态最终整型变量 SYNC_ACTION_ADD_LOCAL，赋值为 2；（定义一个公共静态最终的整型变量 SYNC_ACTION_ADD_LOCAL，值为 2；）
+
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;
+// 公共静态最终整型变量 SYNC_ACTION_DEL_REMOTE，赋值为 3；（定义一个公共静态最终的整型变量 SYNC_ACTION_DEL_REMOTE，值为 3；）
+
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;
+// 公共静态最终整型变量 SYNC_ACTION_DEL_LOCAL，赋值为 4；（定义一个公共静态最终的整型变量 SYNC_ACTION_DEL_LOCAL，值为 4；）
+
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
+// 公共静态最终整型变量 SYNC_ACTION_UPDATE_REMOTE，赋值为 5；（定义一个公共静态最终的整型变量 SYNC_ACTION_UPDATE_REMOTE，值为 5；）
+
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
+// 公共静态最终整型变量 SYNC_ACTION_UPDATE_LOCAL，赋值为 6；（定义一个公共静态最终的整型变量 SYNC_ACTION_UPDATE_LOCAL，值为 6；）
+
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
+// 公共静态最终整型变量 SYNC_ACTION_UPDATE_CONFLICT，赋值为 7；（定义一个公共静态最终的整型变量 SYNC_ACTION_UPDATE_CONFLICT，值为 7；）
+
+    public static final int SYNC_ACTION_ERROR = 8;
+// 公共静态最终整型变量 SYNC_ACTION_ERROR，赋值为 8；（定义一个公共静态最终的整型变量 SYNC_ACTION_ERROR，值为 8；）
+
+    private String mGid;
+// 私有字符串变量 mGid；（定义一个私有字符串变量 mGid；）
+
+    private String mName;
+// 私有字符串变量 mName；（定义一个私有字符串变量 mName；）
+
+    private long mLastModified;
+// 私有长整型变量 mLastModified；（定义一个私有长整型变量 mLastModified；）
+
+    private boolean mDeleted;
+// 私有布尔型变量 mDeleted；（定义一个私有布尔型变量 mDeleted；）
+
+    public Node() {
+// 公共构造函数；（定义一个公共的构造函数；）
+        mGid = null;
+// 初始化 mGid 为 null；（将 mGid 初始化为 null；）
+        mName = "";
+// 初始化 mName 为空字符串；（将 mName 初始化为空字符串；）
+        mLastModified = 0;
+// 初始化 mLastModified 为 0；（将 mLastModified 初始化为 0；）
+        mDeleted = false;
+// 初始化 mDeleted 为 false；（将 mDeleted 初始化为 false；）
+    }
+
+    public abstract JSONObject getCreateAction(int actionId);
+// 公共抽象方法 getCreateAction，接收整型参数 actionId；（定义一个公共抽象方法 getCreateAction，接收一个整型参数 actionId，返回一个 JSONObject 对象；）
+
+    public abstract JSONObject getUpdateAction(int actionId);
+// 公共抽象方法 getUpdateAction，接收整型参数 actionId；（定义一个公共抽象方法 getUpdateAction，接收一个整型参数 actionId，返回一个 JSONObject 对象；）
+
+    public abstract void setContentByRemoteJSON(JSONObject js);
+// 公共抽象方法 setContentByRemoteJSON，接收 JSONObject 参数 js；（定义一个公共抽象方法 setContentByRemoteJSON，接收一个 JSONObject 参数 js；）
+
+    public abstract void setContentByLocalJSON(JSONObject js);
+// 公共抽象方法 setContentByLocalJSON，接收 JSONObject 参数 js；（定义一个公共抽象方法 setContentByLocalJSON，接收一个 JSONObject 参数 js；）
+
+    public abstract JSONObject getLocalJSONFromContent();
+// 公共抽象方法 getLocalJSONFromContent；（定义一个公共抽象方法 getLocalJSONFromContent，返回一个 JSONObject 对象；）
+
+    public abstract int getSyncAction(Cursor c);
+// 公共抽象方法 getSyncAction，接收 Cursor 参数 c；（定义一个公共抽象方法 getSyncAction，接收一个 Cursor 参数 c，返回一个整型值；）
+
+    public void setGid(String gid) {
+// 公共方法 setGid，接收字符串参数 gid；（定义一个名为 setGid 的公共方法，接收一个字符串参数 gid；）
+        this.mGid = gid;
+// 设置 mGid 的值；（将 this.mGid 赋值为 gid；）
+    }
+
+    public void setName(String name) {
+// 公共方法 setName，接收字符串参数 name；（定义一个名为 setName 的公共方法，接收一个字符串参数 name；）
+        this.mName = name;
+// 设置 mName 的值；（将 this.mName 赋值为 name；）
+    }
+
+    public void setLastModified(long lastModified) {
+// 公共方法 setLastModified，接收长整型参数 lastModified；（定义一个名为 setLastModified 的公共方法，接收一个长整型参数 lastModified；）
+        this.mLastModified = lastModified;
+// 设置 mLastModified 的值；（将 this.mLastModified 赋值为 lastModified；）
+    }
+
+    public void setDeleted(boolean deleted) {
+// 公共方法 setDeleted，接收布尔型参数 deleted；（定义一个名为 setDeleted 的公共方法，接收一个布尔型参数 deleted；）
+        this.mDeleted = deleted;
+// 设置 mDeleted 的值；（将 this.mDeleted 赋值为 deleted；）
+    }
+
+    public String getGid() {
+// 公共方法 getGid；（定义一个名为 getGid 的公共方法；）
+        return this.mGid;
+// 返回 mGid 的值；（返回 this.mGid 的值；）
+    }
+
+    public String getName() {
+// 公共方法 getName；（定义一个名为 getName 的公共方法；）
+        return this.mName;
+// 返回 mName 的值；（返回 this.mName 的值；）
+    }
+
+    public long getLastModified() {
+// 公共方法 getLastModified；（定义一个名为 getLastModified 的公共方法；）
+        return this.mLastModified;
+// 返回 mLastModified 的值；（返回 this.mLastModified 的值；）
+    }
+
+    public boolean getDeleted() {
+// 公共方法 getDeleted；（定义一个名为 getDeleted 的公共方法；）
+        return this.mDeleted;
+// 返回 mDeleted 的值；（返回 this.mDeleted 的值；）
+    }
+
+}

src/NotesDatabaseHelper.java

@@ -0,0 +1,492 @@
+/*
+ * 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.
+ */
+
+// 版权声明：2010 - 2011 年，MiCode 开源社区（www.micode.net）。
+// 遵循 Apache License 2.0 许可协议，若不遵守该协议则不可使用此文件。可在以下地址获取许可证副本：http://www.apache.org/licenses/LICENSE-2.0。
+// 除非法律要求或书面同意，否则在该许可证下发布的软件基于“现状”发布，不提供任何形式的保证和条件。
+// 许可证具体条款规定了权限和限制。
+
+package net.micode.notes.data;
+
+// 包声明：这个类属于 net.micode.notes.data 包。
+
+import android.content.ContentValues;
+// 导入用于存储键值对的数据容器类，通常用于向数据库中插入或更新数据。
+import android.content.Context;
+// 导入用于获取应用上下文的类。
+import android.database.sqlite.SQLiteDatabase;
+// 导入用于操作 SQLite 数据库的类。
+import android.database.sqlite.SQLiteOpenHelper;
+// 导入用于创建和管理 SQLite 数据库的帮助类，继承此类可以方便地创建和升级数据库。
+import android.util.Log;
+// 导入 Android 的日志工具类，用于在开发过程中输出调试信息和错误信息。
+
+import net.micode.notes.data.Notes.DataColumns;
+// 导入 Notes 类中的 DataColumns 内部类，可能包含与数据相关的常量或方法。
+import net.micode.notes.data.Notes.DataConstants;
+// 导入 Notes 类中的 DataConstants 内部类，可能包含一些常量定义。
+import net.micode.notes.data.Notes.NoteColumns;
+// 导入 Notes 类中的 NoteColumns 内部类，可能包含与笔记相关的常量或方法。
+
+
+public class NotesDatabaseHelper extends SQLiteOpenHelper {
+// 定义一个名为 NotesDatabaseHelper 的类，继承自 SQLiteOpenHelper，用于创建和管理笔记数据库。
+
+    private static final String DB_NAME = "note.db";
+// 定义数据库名称为“note.db”。
+
+    private static final int DB_VERSION = 4;
+// 定义数据库版本号为 4。
+
+    public interface TABLE {
+// 定义一个内部接口 TABLE，用于表示数据库中的表名。
+        public static final String NOTE = "note";
+// 定义名为“note”的表名常量。
+
+        public static final String DATA = "data";
+// 定义名为“data”的表名常量。
+    }
+
+    private static final String TAG = "NotesDatabaseHelper";
+// 用于日志输出的标记。
+
+    private static NotesDatabaseHelper mInstance;
+// 单例实例。
+
+    private static final String CREATE_NOTE_TABLE_SQL =
+            "CREATE TABLE " + TABLE.NOTE + "(" +
+                    NoteColumns.ID + " INTEGER PRIMARY KEY," +
+                    NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+                    NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+                    NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
+                    NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
+                    NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
+                    NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
+                    ")";
+// 创建“note”表的 SQL 语句。
+
+    private static final String CREATE_DATA_TABLE_SQL =
+            "CREATE TABLE " + TABLE.DATA + "(" +
+                    DataColumns.ID + " INTEGER PRIMARY KEY," +
+                    DataColumns.MIME_TYPE + " TEXT NOT NULL," +
+                    DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 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," +
+                    DataColumns.DATA2 + " INTEGER," +
+                    DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
+                    DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
+                    DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
+                    ")";
+// 创建“data”表的 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 + ");";
+// 创建“data”表中“note_id”索引的 SQL 语句。
+
+    /**
+     * Increase folder's note count when move note to the folder
+     */
+    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 +
+                    " BEGIN " +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
+                    "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+                    " END";
+// 当将笔记移动到文件夹时增加文件夹的笔记数量的触发器 SQL。
+
+    /**
+     * Decrease folder's note count when move note from folder
+     */
+    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 +
+                    " BEGIN " +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
+                    "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+                    "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
+                    " END";
+// 当从文件夹中移动笔记时减少文件夹的笔记数量的触发器 SQL。
+
+    /**
+     * Increase folder's note count when insert new note to the folder
+     */
+    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" +
+                    "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+                    " END";
+// 当向文件夹中插入新笔记时增加文件夹的笔记数量的触发器 SQL。
+
+    /**
+     * Decrease folder's note count when delete note from the folder
+     */
+    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" +
+                    "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+                    "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
+                    " END";
+// 当从文件夹中删除笔记时减少文件夹的笔记数量的触发器 SQL。
+
+    /**
+     * Update note's content when insert data with type {@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 + "'" +
+                    " BEGIN" +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+                    "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+                    " END";
+// 当插入数据类型为 DataConstants.NOTE 的数据时更新笔记内容的触发器 SQL。
+
+    /**
+     * Update note's content when data with {@link DataConstants#NOTE} type has changed
+     */
+    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 + "'" +
+                    " BEGIN" +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+                    "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+                    " END";
+// 当数据类型为 DataConstants.NOTE 的数据发生变化时更新笔记内容的触发器 SQL。
+
+    /**
+     * Update note's content when data with {@link DataConstants#NOTE} type has deleted
+     */
+    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 + "'" +
+                    " BEGIN" +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.SNIPPET + "=''" +
+                    "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
+                    " END";
+// 当数据类型为 DataConstants.NOTE 的数据被删除时更新笔记内容为空的触发器 SQL。
+
+    /**
+     * Delete datas belong to note which has been deleted
+     */
+    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 + ";" +
+                    " END";
+// 当笔记被删除时删除属于该笔记的数据的触发器 SQL。
+
+    /**
+     * Delete notes belong to folder which has been deleted
+     */
+    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 + ";" +
+                    " END";
+// 当文件夹被删除时删除属于该文件夹的笔记的触发器 SQL。
+
+    /**
+     * Move notes belong to folder which has been moved to trash folder
+     */
+    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
+            "CREATE TRIGGER folder_move_notes_on_trash " +
+                    " AFTER UPDATE ON " + TABLE.NOTE +
+                    " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+                    " BEGIN" +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+                    "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
+                    " END";
+// 当文件夹被移动到垃圾桶时，将属于该文件夹的笔记也移动到垃圾桶的触发器 SQL。
+
+    public NotesDatabaseHelper(Context context) {
+// 构造函数，传入上下文对象。
+        super(context, DB_NAME, null, DB_VERSION);
+// 调用父类构造函数，传入数据库名称、游标工厂和版本号。
+    }
+
+    public void createNoteTable(SQLiteDatabase db) {
+// 创建“note”表的方法。
+        db.execSQL(CREATE_NOTE_TABLE_SQL);
+// 执行创建“note”表的 SQL 语句。
+        reCreateNoteTableTriggers(db);
+// 重新创建“note”表的触发器。
+        createSystemFolder(db);
+// 创建系统文件夹。
+        Log.d(TAG, "note table has been created");
+// 输出日志，表明“note”表已创建。
+    }
+
+    private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+// 重新创建“note”表触发器的方法。
+        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);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+    }
+
+    private void createSystemFolder(SQLiteDatabase db) {
+// 创建系统文件夹的方法。
+        ContentValues values = new ContentValues();
+// 创建一个 ContentValues 对象，用于存储要插入数据库的值。
+
+        /**
+         * call record foler for call notes
+         */
+        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
+// 将特定值放入 ContentValues 中，用于插入记录文件夹。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将特定值放入 ContentValues 中，用于插入记录文件夹。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+
+        /**
+         * root folder which is default folder
+         */
+        values.clear();
+// 清空 ContentValues。
+        values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
+// 将特定值放入 ContentValues 中，用于插入根文件夹。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将特定值放入 ContentValues 中，用于插入根文件夹。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+
+        /**
+         * temporary folder which is used for moving note
+         */
+        values.clear();
+// 清空 ContentValues。
+        values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+// 将特定值放入 ContentValues 中，用于插入临时文件夹。
+        values.put        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将特定值放入 ContentValues 中，用于插入临时文件夹的类型为系统类型。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+
+        /**
+         * create trash folder
+         */
+        values.clear();
+// 清空 ContentValues。
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+// 将特定值放入 ContentValues 中，用于插入垃圾桶文件夹的 ID。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将特定值放入 ContentValues 中，用于插入垃圾桶文件夹的类型为系统类型。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+    }
+
+    public void createDataTable(SQLiteDatabase db) {
+// 创建“data”表的方法。
+        db.execSQL(CREATE_DATA_TABLE_SQL);
+// 执行创建“data”表的 SQL 语句。
+        reCreateDataTableTriggers(db);
+// 重新创建“data”表的触发器。
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
+// 创建“data”表中“note_id”索引。
+        Log.d(TAG, "data table has been created");
+// 输出日志，表明“data”表已创建。
+    }
+
+    private void reCreateDataTableTriggers(SQLiteDatabase db) {
+// 重新创建“data”表触发器的方法。
+        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);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+    }
+
+    static synchronized NotesDatabaseHelper getInstance(Context context) {
+// 获取单例实例的静态方法。
+        if (mInstance == null) {
+// 如果单例实例为空。
+            mInstance = new NotesDatabaseHelper(context);
+// 创建一个新的 NotesDatabaseHelper 实例并赋值给单例实例。
+        }
+        return mInstance;
+// 返回单例实例。
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+// 重写 onCreate 方法，在数据库首次创建时被调用。
+        createNoteTable(db);
+// 创建“note”表。
+        createDataTable(db);
+// 创建“data”表。
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+// 重写 onUpgrade 方法，在数据库版本升级时被调用。
+        boolean reCreateTriggers = false;
+// 标记是否需要重新创建触发器。
+        boolean skipV2 = false;
+// 标记是否跳过版本 2 的升级步骤。
+
+        if (oldVersion == 1) {
+// 如果当前数据库版本为 1。
+            upgradeToV2(db);
+// 执行升级到版本 2 的方法。
+            skipV2 = true; // this upgrade including the upgrade from v2 to v3
+// 设置跳过版本 2 的标记为 true，表示这个升级包含了从版本 2 到版本 3 的升级步骤。
+            oldVersion++;
+// 将旧版本号加 1。
+        }
+
+        if (oldVersion == 2 &&!skipV2) {
+// 如果当前数据库版本为 2 且没有跳过版本 2 的升级步骤。
+            upgradeToV3(db);
+// 执行升级到版本 3 的方法。
+            reCreateTriggers = true;
+// 设置需要重新创建触发器的标记为 true。
+            oldVersion++;
+// 将旧版本号加 1。
+        }
+
+        if (oldVersion == 3) {
+// 如果当前数据库版本为 3。
+            upgradeToV4(db);
+// 执行升级到版本 4 的方法。
+            oldVersion++;
+// 将旧版本号加 1。
+        }
+
+        if (reCreateTriggers) {
+// 如果需要重新创建触发器。
+            reCreateNoteTableTriggers(db);
+// 重新创建“note”表的触发器。
+            reCreateDataTableTriggers(db);
+// 重新创建“data”表的触发器。
+        }
+
+        if (oldVersion!= newVersion) {
+// 如果旧版本号与新版本号不相等。
+            throw new IllegalStateException("Upgrade notes database to version " + newVersion
+                    + "fails");
+// 抛出异常，表示数据库升级失败。
+        }
+    }
+
+    private void upgradeToV2(SQLiteDatabase db) {
+// 升级到版本 2 的方法。
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
+// 如果存在“note”表，则删除它。
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+// 如果存在“data”表，则删除它。
+        createNoteTable(db);
+// 创建“note”表。
+        createDataTable(db);
+// 创建“data”表。
+    }
+
+    private void upgradeToV3(SQLiteDatabase db) {
+// 升级到版本 3 的方法。
+        // drop unused triggers
+        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");
+// 删除未使用的触发器（如果存在）。
+        // add a column for gtask id
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+                + " TEXT NOT NULL DEFAULT ''");
+// 在“note”表中添加一个用于存储 gtask id 的列。
+        // add a trash system folder
+        ContentValues values = new ContentValues();
+// 创建一个 ContentValues 对象，用于存储要插入数据库的值。
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+// 将垃圾桶文件夹的 ID 放入 ContentValues 中。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将垃圾桶文件夹的类型为系统类型放入 ContentValues 中。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+    }
+
+    private void upgradeToV4(SQLiteDatabase db) {
+// 升级到版本 4 的方法。
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+                + " INTEGER NOT NULL DEFAULT 0");
+// 在“note”表中添加一个版本号列。
+    }
+}

src/NotesProvider.java

@@ -466,3 +466,82 @@ public class NotesProvider extends ContentProvider {
             default:
                 throw new IllegalArgumentException("Unknown URI " + uri);
                 // 如果 Uri 不匹配任何已知的情况，抛出
+}
+        if (count > 0) {
+// 如果更新操作影响的记录数大于 0。
+            if (updateData) {
+// 如果更新了数据记录。
+                // 如果更新了数据记录，则通知监听器。
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
+// 获取上下文环境，通过内容解析器通知与笔记内容相关的监听器（Notes.CONTENT_NOTE_URI）数据发生了变化，第二个参数为 null 表示没有额外的通知数据。
+            }
+            // 通知监听器指定的 URI 发生了变化。
+            getContext().getContentResolver().notifyChange(uri, null);
+// 获取上下文环境，通过内容解析器通知本次更新操作对应的 URI（uri）的数据发生了变化，第二个参数为 null 表示没有额外的通知数据。
+        }
+        return count;
+// 返回更新操作所影响的记录数。
+
+    }
+
+// 解析选择条件的方法。
+private String parseSelection(String selection) {
+// 定义一个私有方法，接收一个选择条件字符串参数。
+    return (!TextUtils.isEmpty(selection)? " AND (" + selection + ')' : "");
+// 如果选择条件字符串不为空，返回在其前后加上“ AND (”和“)”的字符串；如果为空，返回空字符串。
+}
+
+// 增加笔记版本号的方法。
+private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+// 定义一个私有方法，接收笔记的 ID、选择条件字符串和选择条件参数数组。
+    StringBuilder sql = new StringBuilder(120);
+// 创建一个 StringBuilder 对象，用于构建 SQL 语句，初始容量为 120。
+    sql.append("UPDATE ");
+// 在 StringBuilder 中添加“UPDATE ”。
+    sql.append(TABLE.NOTE);
+// 添加表名 TABLE.NOTE。
+    sql.append(" SET ");
+// 添加“ SET ”。
+    sql.append(NoteColumns.VERSION);
+// 添加版本号列名 NoteColumns.VERSION。
+    sql.append("=" + NoteColumns.VERSION + "+1 ");
+// 添加版本号设置的 SQL 片段，将版本号设置为当前版本号加 1。
+
+    if (id > 0 ||!TextUtils.isEmpty(selection)) {
+// 如果传入的 ID 大于 0 或者选择条件字符串不为空。
+        sql.append(" WHERE ");
+// 在 StringBuilder 中添加“ WHERE ”。
+    }
+    if (id > 0) {
+// 如果传入的 ID 大于 0。
+        sql.append(NoteColumns.ID + "=" + String.valueOf(id));
+// 添加笔记 ID 的条件到 StringBuilder 中。
+    }
+    if (!TextUtils.isEmpty(selection)) {
+// 如果选择条件字符串不为空。
+        String selectString = id > 0? parseSelection(selection) : selection;
+// 如果 ID 大于 0，调用 parseSelection 方法处理选择条件字符串；否则直接使用选择条件字符串。
+        for (String args : selectionArgs) {
+// 遍历选择条件参数数组。
+            selectString = selectString.replaceFirst("\\?", args);
+// 将选择条件字符串中的第一个占位符替换为当前参数值。
+        }
+        sql.append(selectString);
+// 将处理后的选择条件字符串添加到 StringBuilder 中。
+    }
+
+    mHelper.getWritableDatabase().execSQL(sql.toString());
+// 使用数据库帮助类 mHelper 的可写数据库执行构建好的 SQL 语句。
+
+}
+
+// 内容提供器的 getType 方法，用于返回指定 URI 的 MIME 类型。
+@Override
+public String getType(Uri uri) {
+// 重写内容提供器的 getType 方法，接收一个 URI 参数。
+    // TODO Auto-generated method stub
+// 这里是一个待实现的方法注释。
+    return null;
+// 返回 null，表示当前未实现该方法。
+}
+}

src/SqlData.java

@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * （版权所有（c）2010 - 2011，MiCode 开源社区（www.micode.net）。）
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * （根据 Apache License 2.0 版（“许可证”）获得许可；）
+ * 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
+ * （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.gtask.data;
+// 包 net.micode.notes.gtask.data；（这个包的名字是 net.micode.notes.gtask.data。）
+
+import android.content.ContentResolver;
+// 导入 android.content.ContentResolver；（导入 Android 的内容解析器类。）
+import android.content.ContentUris;
+// 导入 android.content.ContentUris；（导入 Android 的内容 URI 工具类。）
+import android.content.ContentValues;
+// 导入 android.content.ContentValues；（导入 Android 的内容值类。）
+import android.content.Context;
+// 导入 android.content.Context；（导入 Android 的上下文类。）
+import android.database.Cursor;
+// 导入 android.database.Cursor；（导入 Android 的数据库游标类。）
+import android.net.Uri;
+// 导入 android.net.Uri；（导入 Android 的统一资源标识符类。）
+import android.util.Log;
+// 导入 android.util.Log；（导入 Android 的日志工具类。）
+
+import net.micode.notes.data.Notes;
+// 导入 net.micode.notes.data.Notes；（导入来自 net.micode.notes.data 的 Notes 类。）
+import net.micode.notes.data.Notes.DataColumns;
+// 导入 net.micode.notes.data.Notes.DataColumns；（导入 Notes 类中的数据列类。）
+import net.micode.notes.data.Notes.DataConstants;
+// 导入 net.micode.notes.data.Notes.DataConstants；（导入 Notes 类中的数据常量类。）
+import net.micode.notes.data.Notes.NoteColumns;
+// 导入 net.micode.notes.data.Notes.NoteColumns；（导入 Notes 类中的笔记列类。）
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+// 导入 net.micode.notes.data.NotesDatabaseHelper.TABLE；（导入 Notes 数据库助手类中的表枚举。）
+import net.micode.notes.gtask.exception.ActionFailureException;
+// 导入 net.micode.notes.gtask.exception.ActionFailureException；（导入特定的异常类。）
+
+import org.json.JSONException;
+// 导入 org.json.JSONException；（导入 JSON 处理的异常类。）
+import org.json.JSONObject;
+// 导入 org.json.JSONObject；（导入 JSON 对象类。）
+
+
+public class SqlData {
+// 公共类 SqlData；（定义一个名为 SqlData 的公共类。）
+    private static final String TAG = SqlData.class.getSimpleName();
+// 私有静态最终字符串变量 TAG，赋值为 SqlData 类的简单名称；（定义一个私有静态最终的字符串变量 TAG，值为 SqlData 类的简单名称。）
+
+    private static final int INVALID_ID = -99999;
+// 私有静态最终整型变量 INVALID_ID，赋值为 -99999；（定义一个私有静态最终的整型变量 INVALID_ID，值为 -99999。）
+
+    public static final String[] PROJECTION_DATA = new String[] {
+            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+            DataColumns.DATA3
+    };
+// 公共静态最终字符串数组变量 PROJECTION_DATA；（定义一个公共静态最终的字符串数组变量 PROJECTION_DATA，包含特定的数据列名称。）
+
+    public static final int DATA_ID_COLUMN = 0;
+// 公共静态最终整型变量 DATA_ID_COLUMN，赋值为 0；（定义一个公共静态最终的整型变量 DATA_ID_COLUMN，值为 0。）
+
+    public static final int DATA_MIME_TYPE_COLUMN = 1;
+// 公共静态最终整型变量 DATA_MIME_TYPE_COLUMN，赋值为 1；（定义一个公共静态最终的整型变量 DATA_MIME_TYPE_COLUMN，值为 1。）
+
+    public static final int DATA_CONTENT_COLUMN = 2;
+// 公共静态最终整型变量 DATA_CONTENT_COLUMN，赋值为 2；（定义一个公共静态最终的整型变量 DATA_CONTENT_COLUMN，值为 2。）
+
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+// 公共静态最终整型变量 DATA_CONTENT_DATA_1_COLUMN，赋值为 3；（定义一个公共静态最终的整型变量 DATA_CONTENT_DATA_1_COLUMN，值为 3。）
+
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+// 公共静态最终整型变量 DATA_CONTENT_DATA_3_COLUMN，赋值为 4；（定义一个公共静态最终的整型变量 DATA_CONTENT_DATA_3_COLUMN，值为 4。）
+
+    private ContentResolver mContentResolver;
+// 私有 ContentResolver 变量 mContentResolver；（定义一个私有变量 mContentResolver，类型为 ContentResolver。）
+
+    private boolean mIsCreate;
+// 私有布尔型变量 mIsCreate；（定义一个私有布尔型变量 mIsCreate。）
+
+    private long mDataId;
+// 私有长整型变量 mDataId；（定义一个私有长整型变量 mDataId。）
+
+    private String mDataMimeType;
+// 私有字符串变量 mDataMimeType；（定义一个私有字符串变量 mDataMimeType。）
+
+    private String mDataContent;
+// 私有字符串变量 mDataContent；（定义一个私有字符串变量 mDataContent。）
+
+    private long mDataContentData1;
+// 私有长整型变量 mDataContentData1；（定义一个私有长整型变量 mDataContentData1。）
+
+    private String mDataContentData3;
+// 私有字符串变量 mDataContentData3；（定义一个私有字符串变量 mDataContentData3。）
+
+    private ContentValues mDiffDataValues;
+// 私有 ContentValues 变量 mDiffDataValues；（定义一个私有变量 mDiffDataValues，类型为 ContentValues。）
+
+    public SqlData(Context context) {
+// 公共构造函数，接收 Context 参数；（定义一个公共构造函数，接收一个 Context 参数。）
+        mContentResolver = context.getContentResolver();
+// 获取内容解析器；（将 context 的内容解析器赋值给 mContentResolver。）
+        mIsCreate = true;
+// 设置创建标志；（将 mIsCreate 设置为 true。）
+        mDataId = INVALID_ID;
+// 初始化数据 ID；（将 mDataId 初始化为 INVALID_ID。）
+        mDataMimeType = DataConstants.NOTE;
+// 初始化数据 MIME 类型；（将 mDataMimeType 初始化为 DataConstants.NOTE。）
+        mDataContent = "";
+// 初始化数据内容；（将 mDataContent 初始化为空字符串。）
+        mDataContentData1 = 0;
+// 初始化数据内容数据 1；（将 mDataContentData1 初始化为 0。）
+        mDataContentData3 = "";
+// 初始化数据内容数据 3；（将 mDataContentData3 初始化为空字符串。）
+        mDiffDataValues = new ContentValues();
+// 创建新的 ContentValues 对象；（创建一个新的 ContentValues 对象并赋值给 mDiffDataValues。）
+    }
+
+    public SqlData(Context context, Cursor c) {
+// 公共构造函数，接收 Context 和 Cursor 参数；（定义一个公共构造函数，接收一个 Context 参数和一个 Cursor 参数。）
+        mContentResolver = context.getContentResolver();
+// 获取内容解析器；（将 context 的内容解析器赋值给 mContentResolver。）
+        mIsCreate = false;
+// 设置创建标志；（将 mIsCreate 设置为 false。）
+        loadFromCursor(c);
+// 从游标加载数据；（调用 loadFromCursor 方法，从传入的游标中加载数据。）
+        mDiffDataValues = new ContentValues();
+// 创建新的 ContentValues 对象；（创建一个新的 ContentValues 对象并赋值给 mDiffDataValues。）
+    }
+
+    private void loadFromCursor(Cursor c) {
+// 私有方法 loadFromCursor，接收 Cursor 参数；（定义一个私有方法 loadFromCursor，接收一个 Cursor 参数。）
+        mDataId = c.getLong(DATA_ID_COLUMN);
+// 获取数据 ID；（从游标中获取指定列的数据 ID，并赋值给 mDataId。）
+        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+// 获取数据 MIME 类型；（从游标中获取指定列的数据 MIME 类型，并赋值给 mDataMimeType。）
+        mDataContent = c.getString(DATA_CONTENT_COLUMN);
+// 获取数据内容；（从游标中获取指定列的数据内容，并赋值给 mDataContent。）
+        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
+// 获取数据内容数据 1；（从游标中获取指定列的数据内容数据 1，并赋值给 mDataContentData1。）
+        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
+// 获取数据内容数据 3；（从游标中获取指定列的数据内容数据 3，并赋值给 mDataContentData3。）
+    }
+
+    public void setContent(JSONObject js) throws JSONException {
+// 公共方法 setContent，接收 JSONObject 参数；（定义一个公共方法 setContent，接收一个 JSONObject 参数。）
+        long dataId = js.has(DataColumns.ID)? js.getLong(DataColumns.ID) : INVALID_ID;
+// 获取数据 ID；（如果 JSONObject 中包含指定键，则获取对应的值作为数据 ID，否则设置为 INVALID_ID。）
+        if (mIsCreate || mDataId!= dataId) {
+// 判断是否创建或数据 ID 不一致；（如果正在创建或者当前数据 ID 与新的数据 ID 不一致。）
+            mDiffDataValues.put(DataColumns.ID, dataId);
+// 更新差异数据值；（将新的数据 ID 放入差异数据值的对应键中。）
+        }
+        mDataId = dataId;
+// 更新数据 ID；（将 dataId 赋值给 mDataId。）
+
+        String dataMimeType = js.has(DataColumns.MIME_TYPE)? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE;
+// 获取数据 MIME 类型；（如果 JSONObject 中包含指定键，则获取对应的值作为数据 MIME 类型，否则设置为 DataConstants.NOTE。）
+        if (mIsCreate ||!mDataMimeType.equals(dataMimeType)) {
+// 判断是否创建或数据 MIME 类型不一致；（如果正在创建或者当前数据 MIME 类型与新的数据 MIME 类型不一致。）
+            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
+// 更新差异数据值；（将新的数据 MIME 类型放入差异数据值的对应键中。）
+        }
+        mDataMimeType = dataMimeType;
+// 更新数据 MIME 类型；（将 dataMimeType 赋值给 mDataMimeType。）
+
+        String dataContent = js.has(DataColumns.CONTENT)? js.getString(DataColumns.CONTENT) : "";
+// 获取数据内容；（如果 JSONObject 中包含指定键，则获取对应的值作为数据内容，否则设置为空字符串。）
+        if (mIsCreate ||!mDataContent.equals(dataContent)) {
+// 判断是否创建或数据内容不一致；（如果正在创建或者当前数据内容与新的数据内容不一致。）
+            mDiffDataValues.put(DataColumns.CONTENT, dataContent);
+// 更新差异数据值；（将新的数据内容放入差异数据值的对应键中。）
+        }
+        mDataContent = dataContent;
+// 更新数据内容；（将 dataContent 赋值给 mDataContent。）
+
+        long dataContentData1 = js.has(DataColumns.DATA1)? js.getLong(DataColumns.DATA1) : 0;
+// 获取数据内容数据 1；（如果 JSONObject 中包含指定键，则获取对应的值作为数据内容数据 1，否则设置为 0。）
+        if (mIsCreate || mDataContentData1!= dataContentData1) {
+// 判断是否创建或数据内容数据 1 不一致；（如果正在创建或者当前数据内容数据 1 与新的数据内容数据 1 不一致。）
+            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
+// 更新差异数据值；（将新的数据内容数据 1 放入差异数据值的对应键中。）
+        }
+        mDataContentData1 = dataContentData1;
+// 更新数据内容数据 1；（将 dataContentData1 赋值给 mDataContentData1。）
+
+        String dataContentData3 = js.has(DataColumns.DATA3)? js.getString(DataColumns.DATA3) : "";
+// 获取数据内容数据 3；（如果 JSONObject 中包含指定键，则获取对应的值作为数据内容数据 3，否则设置为空字符串。）
+        if (mIsCreate ||!mDataContentData3.equals(dataContentData3)) {
+// 判断是否创建或数据内容数据 3 不一致；（如果正在创建或者当前数据内容数据 3 与新的数据内容数据 3 不一致。）
+            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
+// 更新差异数据值；（将新的数据内容数据 3 放入差异数据值的对应键中。）
+        }
+        mDataContentData3 = dataContentData3;
+// 更新数据内容数据 3；（将 dataContentData3 赋值给 mDataContentData3。）
+    }
+
+    public JSONObject getContent() throws JSONException {
+// 公共方法 getContent；（定义一个公共方法 getContent。）
+        if (mIsCreate) {
+// 判断是否正在创建；（如果正在创建。）
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+// 输出错误日志；（打印错误日志，提示“看起来我们还没有在数据库中创建这个。”）
+            return null;
+// 返回 null；（返回 null。）
+        }
+        JSONObject js = new JSONObject();
+// 创建新的 JSONObject 对象；（创建一个新的 JSONObject 对象。）
+        js.put(DataColumns.ID, mDataId);
+// 设置数据 ID；（将 mDataId 放入 JSONObject 的对应键中。）
+        js.put(DataColumns.MIME_TYPE, mDataMimeType);
+// 设置数据 MIME 类型；（将 mDataMimeType 放入 JSONObject 的对应键中。）
+        js.put(DataColumns.CONTENT, mDataContent);
+// 设置数据内容；（将 mDataContent 放入 JSONObject 的对应键中。）
+        js.put(DataColumns.DATA1, mDataContentData1);
+// 设置数据内容数据 1；（将 mDataContentData1 放入 JSONObject 的对应键中。）
+        js.put(DataColumns.DATA3, mDataContentData3);
+// 设置数据内容数据 3；（将 mDataContentData3 放入 JSONObject 的对应键中。）
+        return js;
+// 返回 JSONObject 对象；（返回创建好的 JSONObject 对象。）
+    }
+
+    public void commit(long noteId, boolean validateVersion, long version) {
+// 公共方法 commit，接收长整型、布尔型和长整型参数；（定义一个公共方法 commit，接收一个长整型 noteId、一个布尔型 validateVersion 和一个长整型 version 参数。）
+
+        if (mIsCreate) {
+// 判断是否正在创建；（如果正在创建。）
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
+// 判断数据 ID 是否无效且差异数据值包含特定键；（如果数据 ID 无效且差异数据值中包含指定键。）
+                mDiffDataValues.remove(DataColumns.ID);
+// 移除该键值对；（从差异数据值中移除该键值对。）
+            }
+
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
+// 设置笔记 ID；（将 noteId 放入差异数据值的对应键中。）
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
+// 插入数据；（向 Notes 的内容数据 URI 中插入差异数据值，获取返回的 URI。）
+            try {
+// 尝试执行以下代码块；（开始 try 代码块。）
+                mDataId = Long.valueOf(uri.getPathSegments().get(1));
+// 获取数据 ID；（从返回的 URI 中获取数据 ID，并赋值给 mDataId。）
+            } catch (NumberFormatException e) {
+// 如果发生数字格式异常，进入此代码块；（捕获 NumberFormatException 异常。）
+                Log.e(TAG, "Get note id error :" + e.toString());
+// 输出错误日志；（打印错误日志，提示“获取笔记 ID 错误：”加上异常信息。）
+                throw new ActionFailureException("create note failed");
+// 抛出异常
+       } else {
+// 如果不是正在创建；（如果不是正在创建的状态。）
+            if (mDiffDataValues.size() > 0) {
+// 如果差异数据值不为空；（如果差异数据值有内容。）
+                int result = 0;
+// 初始化结果变量；（先把结果设为 0。）
+                if (!validateVersion) {
+// 如果不验证版本；（如果不需要验证版本。）
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
+// 更新数据；（用内容解析器更新数据，不考虑版本验证。）
+                } else {
+// 如果要验证版本；（如果需要验证版本。）
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+                            "? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[]{
+                            String.valueOf(noteId), String.valueOf(version)
+                    });
+// 更新数据并验证版本；（用内容解析器更新数据，同时验证版本。）
+                }
+                if (result == 0) {
+// 如果更新结果为 0；（如果更新没有效果。）
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+// 输出警告日志；（打印警告日志，提示可能是用户在同步时更新了笔记。）
+                }
+            }
+        }
+
+        mDiffDataValues.clear();
+// 清空差异数据值；（把差异数据值清空。）
+        mIsCreate = false;
+// 设置不是创建状态；（设置当前不是创建新数据的状态。）
+
+    public long getId() {
+// 获取 ID 的方法；（定义一个获取数据 ID 的方法。）
+        return mDataId;
+// 返回数据 ID；（返回当前的数据 ID。）
+    }

src/SqlNote.java

@@ -0,0 +1,711 @@
+/*
+ * 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.gtask.data;
+// 包声明：net.micode.notes.gtask.data
+
+import android.appwidget.AppWidgetManager;
+// 导入安卓小部件管理器类
+import android.content.ContentResolver;
+// 导入内容解析器类
+import android.content.ContentValues;
+// 导入内容值类
+import android.content.Context;
+// 导入上下文类
+import android.database.Cursor;
+// 导入游标类
+import android.net.Uri;
+// 导入统一资源标识符类
+import android.util.Log;
+// 导入日志类
+
+import net.micode.notes.data.Notes;
+// 导入笔记数据类
+import net.micode.notes.data.Notes.DataColumns;
+// 导入笔记数据列类
+import net.micode.notes.data.Notes.NoteColumns;
+// 导入笔记列类
+import net.micode.notes.gtask.exception.ActionFailureException;
+// 导入操作失败异常类
+import net.micode.notes.tool.GTaskStringUtils;
+// 导入工具类中的字符串工具类
+import net.micode.notes.tool.ResourceParser;
+// 导入资源解析器类
+
+import org.json.JSONArray;
+// 导入 JSON 数组类
+import org.json.JSONException;
+// 导入 JSON 异常类
+import org.json.JSONObject;
+// 导入 JSON 对象类
+
+import java.util.ArrayList;
+// 导入 ArrayList 类
+
+public class SqlNote {
+    // SQL 笔记类定义
+
+    private static final String TAG = SqlNote.class.getSimpleName();
+    // 定义静态常量 TAG，为当前类名的简写
+
+    private static final int INVALID_ID = -99999;
+    // 定义无效 ID 的常量值
+
+    public static final String[] PROJECTION_NOTE = new String[]{
+            NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
+            NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
+            NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,
+            NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,
+            NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
+            NoteColumns.VERSION
+    };
+    // 定义笔记投影数组，包含各种列名
+
+    public static final int ID_COLUMN = 0;
+    // ID 列的索引常量
+
+    public static final int ALERTED_DATE_COLUMN = 1;
+    // 提醒日期列的索引常量
+
+    public static final int BG_COLOR_ID_COLUMN = 2;
+    // 背景颜色 ID 列的索引常量
+
+    public static final int CREATED_DATE_COLUMN = 3;
+    // 创建日期列的索引常量
+
+    public static final int HAS_ATTACHMENT_COLUMN = 4;
+    // 是否有附件列的索引常量
+
+    public static final int MODIFIED_DATE_COLUMN = 5;
+    // 修改日期列的索引常量
+
+    public static final int NOTES_COUNT_COLUMN = 6;
+    // 笔记数量列的索引常量
+
+    public static final int PARENT_ID_COLUMN = 7;
+    // 父 ID 列的索引常量
+
+    public static final int SNIPPET_COLUMN = 8;
+    // 摘要列的索引常量
+
+    public static final int TYPE_COLUMN = 9;
+    // 类型列的索引常量
+
+    public static final int WIDGET_ID_COLUMN = 10;
+    // 小部件 ID 列的索引常量
+
+    public static final int WIDGET_TYPE_COLUMN = 11;
+    // 小部件类型列的索引常量
+
+    public static final int SYNC_ID_COLUMN = 12;
+    // 同步 ID 列的索引常量
+
+    public static final int LOCAL_MODIFIED_COLUMN = 13;
+    // 本地修改列的索引常量
+
+    public static final int ORIGIN_PARENT_ID_COLUMN = 14;
+    // 原始父 ID 列的索引常量
+
+    public static final int GTASK_ID_COLUMN = 15;
+    // GTask ID 列的索引常量
+
+    public static final int VERSION_COLUMN = 16;
+    // 版本列的索引常量
+
+    private Context mContext;
+    // 定义上下文变量
+
+    private ContentResolver mContentResolver;
+    // 定义内容解析器变量
+
+    private boolean mIsCreate;
+    // 定义是否为创建状态的变量
+
+    private long mId;
+    // 定义 ID 变量
+
+    private long mAlertDate;
+    // 定义提醒日期变量
+
+    private int mBgColorId;
+    // 定义背景颜色 ID 变量
+
+    private long mCreatedDate;
+    // 定义创建日期变量
+
+    private int mHasAttachment;
+    // 定义是否有附件变量
+
+    private long mModifiedDate;
+    // 定义修改日期变量
+
+    private long mParentId;
+    // 定义父 ID 变量
+
+    private String mSnippet;
+    // 定义摘要变量
+
+    private int mType;
+    // 定义类型变量
+
+    private int mWidgetId;
+    // 定义小部件 ID 变量
+
+    private int mWidgetType;
+    // 定义小部件类型变量
+
+    private long mOriginParent;
+    // 定义原始父 ID 变量
+
+    private long mVersion;
+    // 定义版本变量
+
+    private ContentValues mDiffNoteValues;
+    // 定义差异笔记值变量
+
+    private ArrayList<SqlData> mDataList;
+    // 定义 SQL 数据列表变量
+
+    public SqlNote(Context context) {
+        // 无参构造函数，接受上下文参数
+        mContext = context;
+        // 将传入的上下文赋值给成员变量
+        mContentResolver = context.getContentResolver();
+        // 获取上下文的内容解析器并赋值给成员变量
+        mIsCreate = true;
+        // 设置为创建状态
+        mId = INVALID_ID;
+        // 设置 ID 为无效值
+        mAlertDate = 0;
+        // 设置提醒日期为 0
+        mBgColorId = ResourceParser.getDefaultBgId(context);
+        // 设置背景颜色 ID 为资源解析器获取的默认背景颜色 ID
+        mCreatedDate = System.currentTimeMillis();
+        // 设置创建日期为当前时间戳
+        mHasAttachment = 0;
+        // 设置是否有附件为 0
+        mModifiedDate = System.currentTimeMillis();
+        // 设置修改日期为当前时间戳
+        mParentId = 0;
+        // 设置父 ID 为 0
+        mSnippet = "";
+        // 设置摘要为空字符串
+        mType = Notes.TYPE_NOTE;
+        // 设置类型为笔记类型
+        mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
+        // 设置小部件 ID 为无效值
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+        // 设置小部件类型为无效值
+        mOriginParent = 0;
+        // 设置原始父 ID 为 0
+        mVersion = 0;
+        // 设置版本为 0
+        mDiffNoteValues = new ContentValues();
+        // 创建新的内容值对象并赋值给差异笔记值变量
+        mDataList = new ArrayList<SqlData>();
+        // 创建新的 SQL 数据列表
+    }
+
+    public SqlNote(Context context, Cursor c) {
+        // 接受上下文和游标参数的构造函数
+        mContext = context;
+        // 将传入的上下文赋值给成员变量
+        mContentResolver = context.getContentResolver();
+        // 获取上下文的内容解析器并赋值给成员变量
+        mIsCreate = false;
+        // 设置为非创建状态
+        loadFromCursor(c);
+        // 从游标加载数据
+        mDataList = new ArrayList<SqlData>();
+        // 创建新的 SQL 数据列表
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        // 如果类型为笔记类型，加载数据内容
+        mDiffNoteValues = new ContentValues();
+        // 创建新的内容值对象并赋值给差异笔记值变量
+    }
+
+    public SqlNote(Context context, long id) {
+        // 接受上下文和 ID 参数的构造函数
+        mContext = context;
+        // 将传入的上下文赋值给成员变量
+        mContentResolver = context.getContentResolver();
+        // 获取上下文的内容解析器并赋值给成员变量
+        mIsCreate = false;
+        // 设置为非创建状态
+        loadFromCursor(id);
+        // 从 ID 加载数据
+        mDataList = new ArrayList<SqlData>();
+        // 创建新的 SQL 数据列表
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        // 如果类型为笔记类型，加载数据内容
+        mDiffNoteValues = new ContentValues();
+        // 创建新的内容值对象并赋值给差异笔记值变量
+    }
+
+    private void loadFromCursor(long id) {
+        // 从 ID 加载游标数据的私有方法
+        Cursor c = null;
+        // 初始化游标为 null
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
+                    new String[]{
+                            String.valueOf(id)
+                    }, null);
+            // 查询内容解析器，获取指定 ID 的笔记数据游标
+            if (c!= null) {
+                c.moveToNext();
+                loadFromCursor(c);
+                // 如果游标不为 null，移动到下一行并从游标加载数据
+            } else {
+                Log.w(TAG, "loadFromCursor: cursor = null");
+                // 如果游标为 null，记录日志警告
+            }
+        } finally {
+            if (c!= null)
+                c.close();
+            // 最终，如果游标不为 null，关闭游标
+        }
+    }
+
+    private void loadFromCursor(Cursor c) {
+        // 从游标加载数据的私有方法
+        mId = c.getLong(ID_COLUMN);
+        // 获取游标中 ID 列的值并赋值给成员变量
+        mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
+        // 获取游标中提醒日期列的值并赋值给成员变量
+        mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
+        // 获取游标中背景颜色 ID 列的值并赋值给成员变量
+        mCreatedDate = c.getLong(CREATED_DATE_COLUMN);
+        // 获取游标中创建日期列的值并赋值给成员变量
+        mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);
+        // 获取游标中是否有附件列的值并赋值给成员变量
+        mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);
+        // 获取游标中修改日期列的值并赋值给成员变量
+        mParentId = c.getLong(PARENT_ID_COLUMN);
+        // 获取游标中父 ID 列的值并赋值给成员变量
+        mSnippet = c.getString(SNIPPET_COLUMN);
+        // 获取游标中摘要列的值并赋值给成员变量
+        mType = c.getInt(TYPE_COLUMN);
+        // 获取游标中类型列的值并赋值给成员变量
+        mWidgetId = c.getInt(WIDGET_ID_COLUMN);
+        // 获取游标中小部件 ID 列的值并赋值给成员变量
+        mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
+        // 获取游标中小部件类型列的值并赋值给成员变量
+        mVersion = c.getLong(VERSION_COLUMN);
+        // 获取游标中版本列的值并赋值给成员变量
+    }
+
+    private void loadDataContent() {
+        // 加载数据内容的私有方法
+        Cursor c = null;
+        // 初始化游标为 null
+        mDataList.clear();
+        // 清空数据列表
+        try {
+            c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
+                    "(note_id=?)", new String[]{
+                            String.valueOf(mId)
+                    }, null);
+            // 查询内容解析器，获取指定笔记 ID 的数据游标
+            if (c!= null) {
+                if (c.getCount() == 0) {
+                    Log.w(TAG, "it seems that the note has not data");
+                    // 如果游标计数为 0，记录日志警告
+                    return;
+                }
+                while (c.moveToNext()) {
+                    SqlData data = new SqlData(mContext, c);
+                    mDataList.add(data);
+                    // 如果游标不为 null，遍历游标并创建 SQL 数据对象添加到数据列表
+                }
+            } else {
+                Log.w(TAG, "loadDataContent: cursor = null");
+                // 如果游标为 null，记录日志警告
+            }
+        } finally {
+            if (c!= null)
+                c.close();
+            // 最终，如果游标不为 null，关闭游标
+        }
+    }
+
+    public boolean setContent(JSONObject js) {
+        // 设置内容的方法，接受 JSON 对象参数，返回布尔值
+        try {
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            // 从传入的 JSON 对象中获取名为 GTaskStringUtils.META_HEAD_NOTE 的 JSON 对象
+            if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                Log.w(TAG, "cannot set system folder");
+                // 如果类型为系统文件夹类型，记录日志警告并返回 false
+                return false;
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+                // 如果类型为文件夹类型
+                // for folder we can only update the snnipet and type
+                String snippet = note.has(NoteColumns.SNIPPET)? note
+                       .getString(NoteColumns.SNIPPET) : "";
+                // 获取摘要，如果存在则获取，否则为空字符串
+                if (mIsCreate ||!mSnippet.equals(snippet)) {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+                }
+                // 如果为创建状态或摘要与当前不同，将摘要添加到差异笔记值中
+                mSnippet = snippet;
+                // 更新摘要变量
+
+                int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;
+                // 获取类型，如果存在则获取，否则为笔记类型
+                if (mIsCreate || mType!= type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);
+                }
+                // 如果为创建状态或类型与当前不同，将类型添加到差异笔记值中
+                mType = type;
+                // 更新类型变量
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+                // 如果类型为笔记类型
+                JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+                // 获取数据数组
+                long id = note.has(NoteColumns.ID)? note.getLong(NoteColumns.ID) : INVALID_ID;
+                // 获取 ID，如果存在则获取，否则为无效值
+                if (mIsCreate || mId!= id) {
+                    mDiffNoteValues.put(NoteColumns.ID, id);
+                }
+                // 如果为创建状态或 ID 与当前不同，将 ID 添加到差异笔记值中
+                mId = id;
+                // 更新 ID 变量
+
+                long alertDate = note.has(NoteColumns.ALERTED_DATE)? note
+                       .getLong(NoteColumns.ALERTED_DATE) : 0;
+                // 获取提醒日期，如果存在则获取，否则为 0
+                if (mIsCreate || mAlertDate!= alertDate) {
+                    mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
+                }
+                // 如果为创建状态或提醒日期与当前不同，将提醒日期添加到差异笔记值中
+                mAlertDate = alertDate;
+                // 更新提醒日期变量
+
+                int bgColorId = note.has(NoteColumns.BG_COLOR_ID)? note
+                       .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
+                // 获取背景颜色 ID，如果存在则获取，否则为默认背景颜色 ID
+                if (mIsCreate || mBgColorId!= bgColorId) {
+                    mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
+                }
+                // 如果为创建状态或背景颜色 ID 与当前不同，将背景颜色 ID 添加到差异笔记值中
+                mBgColorId = bgColorId;
+                // 更新背景颜色 ID 变量
+
+                long createDate = note.has(NoteColumns.CREATED_DATE)? note
+                       .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
+                // 获取创建日期，如果存在则获取，否则为当前时间戳
+                if (mIsCreate || mCreatedDate!= createDate) {
+                    mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
+                }
+                // 如果为创建状态或创建日期与当前不同，将创建日期添加到差异笔记值中
+                mCreatedDate = createDate;
+                // 更新创建日期变量
+int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT)? note
+       .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
+// 判断 JSON 对象 note 中是否存在 HAS_ATTACHMENT 字段，如果有则获取其整数值，否则将 hasAttachment 初始化为 0。
+
+if (mIsCreate || mHasAttachment!= hasAttachment) {
+    mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
+}
+// 如果当前处于创建状态或者当前的 hasAttachment 值与新获取的值不同，则将新的 hasAttachment 值放入差异笔记值的 HAS_ATTACHMENT 字段中。
+
+mHasAttachment = hasAttachment;
+// 更新当前对象的 hasAttachment 变量。
+
+long modifiedDate = note.has(NoteColumns.MODIFIED_DATE)? note
+       .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
+// 判断 JSON 对象 note 中是否存在 MODIFIED_DATE 字段，如果有则获取其长整数值，否则将 modifiedDate 初始化为当前时间戳。
+
+if (mIsCreate || mModifiedDate!= modifiedDate) {
+    mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
+}
+// 如果当前处于创建状态或者当前的 modifiedDate 值与新获取的值不同，则将新的 modifiedDate 值放入差异笔记值的 MODIFIED_DATE 字段中。
+
+mModifiedDate = modifiedDate;
+// 更新当前对象的 modifiedDate 变量。
+
+long parentId = note.has(NoteColumns.PARENT_ID)? note
+       .getLong(NoteColumns.PARENT_ID) : 0;
+// 判断 JSON 对象 note 中是否存在 PARENT_ID 字段，如果有则获取其长整数值，否则将 parentId 初始化为 0。
+
+if (mIsCreate || mParentId!= parentId) {
+    mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
+}
+// 如果当前处于创建状态或者当前的 parentId 值与新获取的值不同，则将新的 parentId 值放入差异笔记值的 PARENT_ID 字段中。
+
+mParentId = parentId;
+// 更新当前对象的 parentId 变量。
+
+String snippet = note.has(NoteColumns.SNIPPET)? note
+       .getString(NoteColumns.SNIPPET) : "";
+// 判断 JSON 对象 note 中是否存在 SNIPPET 字段，如果有则获取其字符串值，否则将 snippet 初始化为空字符串。
+
+if (mIsCreate ||!mSnippet.equals(snippet)) {
+    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+}
+// 如果当前处于创建状态或者当前的 snippet 值与新获取的值不同，则将新的 snippet 值放入差异笔记值的 SNIPPET 字段中。
+
+mSnippet = snippet;
+// 更新当前对象的 snippet 变量。
+
+int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE)
+        : Notes.TYPE_NOTE;
+// 判断 JSON 对象 note 中是否存在 TYPE 字段，如果有则获取其整数值，否则将 type 初始化为笔记类型。
+
+if (mIsCreate || mType!= type) {
+    mDiffNoteValues.put(NoteColumns.TYPE, type);
+}
+// 如果当前处于创建状态或者当前的 type 值与新获取的值不同，则将新的 type 值放入差异笔记值的 TYPE 字段中。
+
+mType = type;
+// 更新当前对象的 type 变量。
+
+int widgetId = note.has(NoteColumns.WIDGET_ID)? note.getInt(NoteColumns.WIDGET_ID)
+        : AppWidgetManager.INVALID_APPWIDGET_ID;
+// 判断 JSON 对象 note 中是否存在 WIDGET_ID 字段，如果有则获取其整数值，否则将 widgetId 初始化为无效小部件 ID。
+
+if (mIsCreate || mWidgetId!= widgetId) {
+    mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
+}
+// 如果当前处于创建状态或者当前的 widgetId 值与新获取的值不同，则将新的 widgetId 值放入差异笔记值的 WIDGET_ID 字段中。
+
+mWidgetId = widgetId;
+// 更新当前对象的 widgetId 变量。
+
+int widgetType = note.has(NoteColumns.WIDGET_TYPE)? note
+       .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
+// 判断 JSON 对象 note 中是否存在 WIDGET_TYPE 字段，如果有则获取其整数值，否则将 widgetType 初始化为无效小部件类型。
+
+if (mIsCreate || mWidgetType!= widgetType) {
+    mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
+}
+// 如果当前处于创建状态或者当前的 widgetType 值与新获取的值不同，则将新的 widgetType 值放入差异笔记值的 WIDGET_TYPE 字段中。
+
+mWidgetType = widgetType;
+// 更新当前对象的 widgetType 变量。
+
+long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID)? note
+       .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
+// 判断 JSON 对象 note 中是否存在 ORIGIN_PARENT_ID 字段，如果有则获取其长整数值，否则将 originParent 初始化为 0。
+
+if (mIsCreate || mOriginParent!= originParent) {
+    mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
+}
+// 如果当前处于创建状态或者当前的 originParent 值与新获取的值不同，则将新的 originParent 值放入差异笔记值的 ORIGIN_PARENT_ID 字段中。
+
+mOriginParent = originParent;
+// 更新当前对象的 originParent 变量。
+
+for (int i = 0; i < dataArray.length(); i++) {
+    JSONObject data = dataArray.getJSONObject(i);
+    // 从 JSON 数组 dataArray 中获取第 i 个元素，即一个 JSON 对象，并赋值给 data。
+    SqlData sqlData = null;
+    // 初始化一个 SqlData 对象为 null。
+    if (data.has(DataColumns.ID)) {
+        long dataId = data.getLong(DataColumns.ID);
+        // 如果 data 中包含 ID 字段，则获取其长整数值并赋值给 dataId。
+        for (SqlData temp : mDataList) {
+            if (dataId == temp.getId()) {
+                sqlData = temp;
+            }
+        }
+        // 在当前对象的 mDataList 中遍历每个 SqlData 对象 temp，如果 dataId 与 temp 的 ID 相等，则将 temp 赋值给 sqlData。
+    }
+
+    if (sqlData == null) {
+        sqlData = new SqlData(mContext);
+        mDataList.add(sqlData);
+    }
+    // 如果 sqlData 为 null，即没有找到匹配的 SqlData 对象，则创建一个新的 SqlData 对象并添加到 mDataList 中。
+
+    sqlData.setContent(data);
+    // 调用 sqlData 的 setContent 方法，将当前的 data 对象作为参数传入。
+}
+java
+复制
+public JSONObject getContent() {
+    try {
+        JSONObject js = new JSONObject();
+        // 创建一个新的 JSON 对象 js。
+        if (mIsCreate) {
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+            return null;
+        }
+        // 如果当前处于创建状态，则记录日志并返回 null。
+
+        JSONObject note = new JSONObject();
+        // 创建一个新的 JSON 对象 note。
+        if (mType == Notes.TYPE_NOTE) {
+            note.put(NoteColumns.ID, mId);
+            note.put(NoteColumns.ALERTED_DATE, mAlertDate);
+            note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
+            note.put(NoteColumns.CREATED_DATE, mCreatedDate);
+            note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
+            note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
+            note.put(NoteColumns.PARENT_ID, mParentId);
+            note.put(NoteColumns.SNIPPET, mSnippet);
+            note.put(NoteColumns.TYPE, mType);
+            note.put(NoteColumns.WIDGET_ID, mWidgetId);
+            note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
+            note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
+            js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+            // 如果当前对象的类型是笔记类型，则将各种属性放入 note 中，并将 note 放入 js 的特定键下。
+
+            JSONArray dataArray = new JSONArray();
+            for (SqlData sqlData : mDataList) {
+                JSONObject data = sqlData.getContent();
+                if (data!= null) {
+                    dataArray.put(data);
+                }
+            }
+            js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+            // 创建一个新的 JSON 数组 dataArray，遍历数据列表获取每个 SqlData 的内容放入 JSON 数组中，再将 dataArray 放入 js 的特定键下。
+        } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
+            note.put(NoteColumns.ID, mId);
+            note.put(NoteColumns.TYPE, mType);
+            note.put(NoteColumns.SNIPPET, mSnippet);
+            js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+        }
+        // 如果当前对象的类型是文件夹类型或系统类型，则只将 ID、类型和摘要放入 note 中，再将 note 放入 js 的特定键下。
+
+        return js;
+    } catch (JSONException e) {
+        Log.e(TAG, e.toString());
+        e.printStackTrace();
+    }
+    return null;
+}
+java
+复制
+public void setParentId(long id) {
+    mParentId = id;
+    // 更新当前对象的父 ID 变量。
+    mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
+    // 将新的父 ID 放入差异笔记值的 PARENT_ID 字段中。
+}
+
+public void setGtaskId(String gid) {
+    mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
+    // 将新的 GTask ID 放入差异笔记值的 GTASK_ID 字段中。
+}
+
+public void setSyncId(long syncId) {
+    mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
+    // 将新的同步 ID 放入差异笔记值的 SYNC_ID 字段中。
+}
+
+public void resetLocalModified() {
+    mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
+    // 将本地修改状态设置为 0，并放入差异笔记值的 LOCAL_MODIFIED 字段中。
+}
+
+public long getId() {
+    return mId;
+    // 返回当前对象的 ID。
+}
+
+public long getParentId() {
+    return mParentId;
+    // 返回当前对象的父 ID。
+}
+
+public String getSnippet() {
+    return mSnippet;
+    // 返回当前对象的摘要。
+}
+
+public boolean isNoteType() {
+    return mType == Notes.TYPE_NOTE;
+    // 判断是否是笔记类型的方法。如果当前对象的类型等于笔记类型，则返回 true，否则返回 false。
+}
+
+public void commit(boolean validateVersion) {
+    if (mIsCreate) {
+        if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
+            mDiffNoteValues.remove(NoteColumns.ID);
+        }
+        // 如果当前处于创建状态且 ID 为无效值且差异笔记值中包含 ID 字段，则移除该 ID 字段。
+
+        Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
+        try {
+            mId = Long.valueOf(uri.getPathSegments().get(1));
+        } catch (NumberFormatException e) {
+            Log.e(TAG, "Get note id error :" + e.toString());
+            throw new ActionFailureException("create note failed");
+        }
+        // 插入新的笔记数据到内容解析器中，并获取新插入的笔记 ID。如果插入失败则抛出异常。
+
+        if (mId == 0) {
+            throw new IllegalStateException("Create thread id failed");
+        }
+        // 如果当前 ID 为 0，则抛出非法状态异常。
+
+        if (mType == Notes.TYPE_NOTE) {
+            for (SqlData sqlData : mDataList) {
+                sqlData.commit(mId, false, -1);
+            }
+        }
+        // 如果类型是笔记类型，则对数据列表中的每个 SqlData 对象调用提交方法。
+    } else {
+        if (mId <= 0 && mId!= Notes.ID_ROOT_FOLDER && mId!= Notes.ID_CALL_RECORD_FOLDER) {
+            Log.e(TAG, "No such note");
+            throw new IllegalStateException("Try to update note with invalid id");
+        }
+        // 如果不是创建状态且 ID 无效（不等于根文件夹 ID 和通话记录文件夹 ID），则抛出异常。
+
+        if (mDiffNoteValues.size() > 0) {
+            mVersion++;
+            int result = 0;
+            if (!validateVersion) {
+                result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                        + NoteColumns.ID + "=?)", new String[]{
+                        String.valueOf(mId)
+                });
+            } else {
+                result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                        + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+                        new String[]{
+                                String.valueOf(mId), String.valueOf(mVersion)
+                        });
+            }
+            if (result == 0) {
+                Log.w(TAG, "there is no update. maybe user updates note when syncing");
+            }
+        }
+        // 如果差异笔记值不为空，则更新版本号，并根据 validateVersion 的值选择不同的更新方式。如果更新结果为 0，则记录日志警告。
+
+        if (mType == Notes.TYPE_NOTE) {
+            for (SqlData sqlData : mDataList) {
+                sqlData.commit(mId, validateVersion, mVersion);
+            }
+        }
+        // 如果类型是笔记类型，则对数据列表中的每个 SqlData 对象调用提交方法。
+    }
+
+    // refresh local info
+    loadFromCursor(mId);
+    if (mType == Notes.TYPE_NOTE)
+        loadDataContent();
+    // 刷新本地信息，根据 ID 重新加载当前对象的数据，如果类型是笔记类型，则加载数据内容。
+
+    mDiffNoteValues.clear();
+    mIsCreate = false;
+    // 清空差异笔记值，并设置为非创建状态。
+}

src/net/micode/notes/data/Notes.java

@@ -0,0 +1,373 @@
+/*
+ * 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.
+ */
+
+// 版权声明：2010 - 2011 年，MiCode 开源社区（www.micode.net）。
+// 在 Apache License 2.0 协议下授权；你不得在不符合该协议的情况下使用此文件。你可以在以下地址获取该协议的副本：http://www.apache.org/licenses/LICENSE-2.0。
+// 除非适用法律要求或书面同意，否则根据本许可证分发的软件是基于“按原样”基础提供的，不附带任何明示或暗示的保证或条件。请参阅许可证以了解管理权限和限制的特定语言。
+
+package net.micode.notes.data;
+// 包名为 net.micode.notes.data。
+
+import android.net.Uri;
+// 导入安卓网络包中的 Uri 类。
+
+public class Notes {
+// 定义公共类 Notes。
+
+    public static final String AUTHORITY = "micode_notes";
+    // 定义静态常量 AUTHORITY，值为“micode_notes”。
+
+    public static final String TAG = "Notes";
+    // 定义静态常量 TAG，值为“Notes”。
+
+    public static final int TYPE_NOTE = 0;
+    // 定义静态常量 TYPE_NOTE，值为 0。
+
+    public static final int TYPE_FOLDER = 1;
+    // 定义静态常量 TYPE_FOLDER，值为 1。
+
+    public static final int TYPE_SYSTEM = 2;
+    // 定义静态常量 TYPE_SYSTEM，值为 2。
+
+    /**
+     * 以下 ID 是系统文件夹的标识符。
+     * {@link Notes#ID_ROOT_FOLDER} 是默认文件夹。
+     * {@link Notes#ID_TEMPARAY_FOLDER} 用于不属于任何文件夹的笔记。
+     * {@link Notes#ID_CALL_RECORD_FOLDER} 用于存储通话记录。
+     */
+    // 注释解释了后续常量的用途。
+
+    public static final int ID_ROOT_FOLDER = 0;
+    // 定义静态常量 ID_ROOT_FOLDER，值为 0。
+
+    public static final int ID_TEMPARAY_FOLDER = -1;
+    // 定义静态常量 ID_TEMPARAY_FOLDER，值为 -1。
+
+    public static final int ID_CALL_RECORD_FOLDER = -2;
+    // 定义静态常量 ID_CALL_RECORD_FOLDER，值为 -2。
+
+    public static final int ID_TRASH_FOLER = -3;
+    // 定义静态常量 ID_TRASH_FOLER，值为 -3。
+
+    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
+    // 定义静态常量 INTENT_EXTRA_ALERT_DATE，值为“net.micode.notes.alert_date”。
+
+    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
+    // 定义静态常量 INTENT_EXTRA_BACKGROUND_ID，值为“net.micode.notes.background_color_id”。
+
+    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
+    // 定义静态常量 INTENT_EXTRA_WIDGET_ID，值为“net.micode.notes.widget_id”。
+
+    public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
+    // 定义静态常量 INTENT_EXTRA_WIDGET_TYPE，值为“net.micode.notes.widget_type”。
+
+    public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
+    // 定义静态常量 INTENT_EXTRA_FOLDER_ID，值为“net.micode.notes.folder_id”。
+
+    public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
+    // 定义静态常量 INTENT_EXTRA_CALL_DATE，值为“net.micode.notes.call_date”。
+
+    public static final int TYPE_WIDGET_INVALIDE = -1;
+    // 定义静态常量 TYPE_WIDGET_INVALIDE，值为 -1。
+
+    public static final int TYPE_WIDGET_2X = 0;
+    // 定义静态常量 TYPE_WIDGET_2X，值为 0。
+
+    public static final int TYPE_WIDGET_4X = 1;
+    // 定义静态常量 TYPE_WIDGET_4X，值为 1。
+
+    public static class DataConstants {
+    // 定义静态内部类 DataConstants。
+
+        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
+        // 定义静态常量 NOTE，值为 TextNote 类中的 CONTENT_ITEM_TYPE。
+
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
+        // 定义静态常量 CALL_NOTE，值为 CallNote 类中的 CONTENT_ITEM_TYPE。
+
+    }
+
+    /**
+     * 用于查询所有笔记和文件夹的 Uri。
+     */
+
+    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
+    // 定义静态常量 CONTENT_NOTE_URI，通过解析字符串“content://micode_notes/note”得到 Uri 对象。
+
+    /**
+     * 用于查询数据的 Uri。
+     */
+    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
+    // 定义静态常量 CONTENT_DATA_URI，通过解析字符串“content://micode_notes/data”得到 Uri 对象。
+
+    public interface NoteColumns {
+    // 定义公共接口 NoteColumns。
+
+        /**
+         * 一行的唯一 ID。类型：整数（长整型）。
+         */
+
+        public static final String ID = "_id";
+        // 定义静态常量 ID，值为“_id”。
+
+        /**
+         * 笔记或文件夹的父级 ID。类型：整数（长整型）。
+         */
+
+        public static final String PARENT_ID = "parent_id";
+        // 定义静态常量 PARENT_ID，值为“parent_id”。
+
+        /**
+         * 笔记或文件夹的创建日期。类型：整数（长整型）。
+         */
+
+        public static final String CREATED_DATE = "created_date";
+        // 定义静态常量 CREATED_DATE，值为“created_date”。
+
+        /**
+         * 最新修改日期。类型：整数（长整型）。
+         */
+
+        public static final String MODIFIED_DATE = "modified_date";
+        // 定义静态常量 MODIFIED_DATE，值为“modified_date”。
+
+        /**
+         * 提醒日期。类型：整数（长整型）。
+         */
+
+        public static final String ALERTED_DATE = "alert_date";
+        // 定义静态常量 ALERTED_DATE，值为“alert_date”。
+
+        /**
+         * 文件夹的名称或笔记的文本内容。类型：文本。
+         */
+
+        public static final String SNIPPET = "snippet";
+        // 定义静态常量 SNIPPET，值为“snippet”。
+
+        /**
+         * 笔记的小部件 ID。类型：整数（长整型）。
+         */
+
+        public static final String WIDGET_ID = "widget_id";
+        // 定义静态常量 WIDGET_ID，值为“widget_id”。
+
+        /**
+         * 笔记的小部件类型。类型：整数（长整型）。
+         */
+
+        public static final String WIDGET_TYPE = "widget_type";
+        // 定义静态常量 WIDGET_TYPE，值为“widget_type”。
+
+        /**
+         * 笔记的背景颜色 ID。类型：整数（长整型）。
+         */
+
+        public static final String BG_COLOR_ID = "bg_color_id";
+        // 定义静态常量 BG_COLOR_ID，值为“bg_color_id”。
+
+        /**
+         * 对于文本笔记，它没有附件；对于多媒体笔记，它至少有一个附件。类型：整数。
+         */
+
+        public static final String HAS_ATTACHMENT = "has_attachment";
+        // 定义静态常量 HAS_ATTACHMENT，值为“has_attachment”。
+
+        /**
+         * 文件夹中的笔记数量。类型：整数（长整型）。
+         */
+
+        public static final String NOTES_COUNT = "notes_count";
+        // 定义静态常量 NOTES_COUNT，值为“notes_count”。
+
+        /**
+         * 文件类型：文件夹或笔记。类型：整数。
+         */
+
+        public static final String TYPE = "type";
+        // 定义静态常量 TYPE，值为“type”。
+
+        /**
+         * 最后一次同步的 ID。类型：整数（长整型）。
+         */
+
+        public static final String SYNC_ID = "sync_id";
+        // 定义静态常量 SYNC_ID，值为“sync_id”。
+
+        /**
+         * 表示本地是否已修改的标志。类型：整数。
+         */
+
+        public static final String LOCAL_MODIFIED = "local_modified";
+        // 定义静态常量 LOCAL_MODIFIED，值为“local_modified”。
+
+        /**
+         * 移动到临时文件夹之前的原始父级 ID。类型：整数。
+         */
+
+        public static final String ORIGIN_PARENT_ID = "origin_parent_id";
+        // 定义静态常量 ORIGIN_PARENT_ID，值为“origin_parent_id”。
+
+        /**
+         * gtask 的 ID。类型：文本。
+         */
+
+        public static final String GTASK_ID = "gtask_id";
+        // 定义静态常量 GTASK_ID，值为“gtask_id”。
+
+        /**
+         * 版本代码。类型：整数（长整型）。
+         */
+
+        public static final String VERSION = "version";
+        // 定义静态常量 VERSION，值为“version”。
+
+    }
+
+    public interface DataColumns {
+    // 定义公共接口 DataColumns。
+
+        /**
+         * 一行的唯一 ID。类型：整数（长整型）。
+         */
+
+        public static final String ID = "_id";
+        // 定义静态常量 ID，值为“_id”。
+
+        /**
+         * 这一行所代表的项目的 MIME 类型。类型：文本。
+         */
+
+        public static final String MIME_TYPE = "mime_type";
+        // 定义静态常量 MIME_TYPE，值为“mime_type”。
+
+        /**
+         * 此数据所属笔记的引用 ID。类型：整数（长整型）。
+         */
+
+        public static final String NOTE_ID = "note_id";
+        // 定义静态常量 NOTE_ID，值为“note_id”。
+
+        /**
+         * 笔记或文件夹的创建日期。类型：整数（长整型）。
+         */
+
+        public static final String CREATED_DATE = "created_date";
+        // 定义静态常量 CREATED_DATE，值为“created_date”。
+
+        /**
+         * 最新修改日期。类型：整数（长整型）。
+         */
+
+        public static final String MODIFIED_DATE = "modified_date";
+        // 定义静态常量 MODIFIED_DATE，值为“modified_date”。
+
+        /**
+         * 数据的内容。类型：文本。
+         */
+
+        public static final String CONTENT = "content";
+        // 定义静态常量 CONTENT，值为“content”。
+
+        /**
+         * 通用数据列，其含义特定于{@link #MIMETYPE}，用于整数数据类型。类型：整数。
+         */
+
+        public static final String DATA1 = "data1";
+        // 定义静态常量 DATA1，值为“data1”。
+
+        /**
+         * 通用数据列，其含义特定于{@link #MIMETYPE}，用于整数数据类型。类型：整数。
+         */
+
+        public static final String DATA2 = "data2";
+        // 定义静态常量 DATA2，值为“data2”。
+
+        /**
+         * 通用数据列，其含义特定于{@link #MIMETYPE}，用于文本数据类型。类型：文本。
+         */
+
+        public static final String DATA3 = "data3";
+        // 定义静态常量 DATA3，值为“data3”。
+
+        /**
+         * 通用数据列，其含义特定于{@link #MIMETYPE}，用于文本数据类型。类型：文本。
+         */
+
+        public static final String DATA4 = "data4";
+        // 定义静态常量 DATA4，值为“data4”。
+
+        /**
+         * 通用数据列，其含义特定于{@link #MIMETYPE}，用于文本数据类型。类型：文本。
+         */
+
+        public static final String DATA5 = "data5";
+        // 定义静态常量 DATA5，值为“data5”。
+
+    }
+
+    public static final class TextNote implements DataColumns {
+    // 定义静态内部类 TextNote，实现 DataColumns 接口。
+
+        /**
+         * 模式，用于指示文本是否处于清单模式。类型：整数，1 表示清单模式，0 表示正常模式。
+         */
+
+        public static final String MODE = DATA1;
+        // 定义静态常量 MODE，值为 DATA1。
+
+        public static final int MODE_CHECK_LIST = 1;
+        // 定义静态常量 MODE_CHECK_LIST，值为 1。
+
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
+        // 定义静态常量 CONTENT_TYPE，值为“vnd.android.cursor.dir/text_note”。
+
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
+        // 定义静态常量 CONTENT_ITEM_TYPE，值为“vnd.android.cursor.item/text_note”。
+
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
+        // 定义静态常量 CONTENT_URI，通过解析字符串“content://micode_notes/text_note”得到 Uri 对象。
+
+    }
+
+    public static final class CallNote implements DataColumns {
+    // 定义静态内部类 CallNote，实现 DataColumns 接口。
+
+        /**
+         * 此记录的通话日期。类型：整数（长整型）。
+         */
+
+        public static final String CALL_DATE = DATA1;
+        // 定义静态常量 CALL_DATE，值为 DATA1。
+
+        /**
+         * 此记录的电话号码。类型：文本。
+         */
+
+        public static final String PHONE_NUMBER = DATA3;
+        // 定义静态常量 PHONE_NUMBER，值为 DATA3。
+
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
+        // 定义静态常量 CONTENT_TYPE，值为“vnd.android.cursor.dir/call_note”。
+
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
+        // 定义静态常量 CONTENT_ITEM_TYPE，值为“vnd.android.cursor.item/call_note”。
+
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
+        // 定义静态常量 CONTENT_URI，通过解析字符串“content://micode_notes/call_note”得到 Uri 对象。
+
+    }
+}

src/net/micode/notes/data/NotesDatabaseHelper.java

@@ -0,0 +1,492 @@
+/*
+ * 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.
+ */
+
+// 版权声明：2010 - 2011 年，MiCode 开源社区（www.micode.net）。
+// 遵循 Apache License 2.0 许可协议，若不遵守该协议则不可使用此文件。可在以下地址获取许可证副本：http://www.apache.org/licenses/LICENSE-2.0。
+// 除非法律要求或书面同意，否则在该许可证下发布的软件基于“现状”发布，不提供任何形式的保证和条件。
+// 许可证具体条款规定了权限和限制。
+
+package net.micode.notes.data;
+
+// 包声明：这个类属于 net.micode.notes.data 包。
+
+import android.content.ContentValues;
+// 导入用于存储键值对的数据容器类，通常用于向数据库中插入或更新数据。
+import android.content.Context;
+// 导入用于获取应用上下文的类。
+import android.database.sqlite.SQLiteDatabase;
+// 导入用于操作 SQLite 数据库的类。
+import android.database.sqlite.SQLiteOpenHelper;
+// 导入用于创建和管理 SQLite 数据库的帮助类，继承此类可以方便地创建和升级数据库。
+import android.util.Log;
+// 导入 Android 的日志工具类，用于在开发过程中输出调试信息和错误信息。
+
+import net.micode.notes.data.Notes.DataColumns;
+// 导入 Notes 类中的 DataColumns 内部类，可能包含与数据相关的常量或方法。
+import net.micode.notes.data.Notes.DataConstants;
+// 导入 Notes 类中的 DataConstants 内部类，可能包含一些常量定义。
+import net.micode.notes.data.Notes.NoteColumns;
+// 导入 Notes 类中的 NoteColumns 内部类，可能包含与笔记相关的常量或方法。
+
+
+public class NotesDatabaseHelper extends SQLiteOpenHelper {
+// 定义一个名为 NotesDatabaseHelper 的类，继承自 SQLiteOpenHelper，用于创建和管理笔记数据库。
+
+    private static final String DB_NAME = "note.db";
+// 定义数据库名称为“note.db”。
+
+    private static final int DB_VERSION = 4;
+// 定义数据库版本号为 4。
+
+    public interface TABLE {
+// 定义一个内部接口 TABLE，用于表示数据库中的表名。
+        public static final String NOTE = "note";
+// 定义名为“note”的表名常量。
+
+        public static final String DATA = "data";
+// 定义名为“data”的表名常量。
+    }
+
+    private static final String TAG = "NotesDatabaseHelper";
+// 用于日志输出的标记。
+
+    private static NotesDatabaseHelper mInstance;
+// 单例实例。
+
+    private static final String CREATE_NOTE_TABLE_SQL =
+            "CREATE TABLE " + TABLE.NOTE + "(" +
+                    NoteColumns.ID + " INTEGER PRIMARY KEY," +
+                    NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+                    NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+                    NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
+                    NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
+                    NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+                    NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
+                    NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
+                    ")";
+// 创建“note”表的 SQL 语句。
+
+    private static final String CREATE_DATA_TABLE_SQL =
+            "CREATE TABLE " + TABLE.DATA + "(" +
+                    DataColumns.ID + " INTEGER PRIMARY KEY," +
+                    DataColumns.MIME_TYPE + " TEXT NOT NULL," +
+                    DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 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," +
+                    DataColumns.DATA2 + " INTEGER," +
+                    DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
+                    DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
+                    DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
+                    ")";
+// 创建“data”表的 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 + ");";
+// 创建“data”表中“note_id”索引的 SQL 语句。
+
+    /**
+     * Increase folder's note count when move note to the folder
+     */
+    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 +
+                    " BEGIN " +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
+                    "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+                    " END";
+// 当将笔记移动到文件夹时增加文件夹的笔记数量的触发器 SQL。
+
+    /**
+     * Decrease folder's note count when move note from folder
+     */
+    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 +
+                    " BEGIN " +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
+                    "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+                    "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
+                    " END";
+// 当从文件夹中移动笔记时减少文件夹的笔记数量的触发器 SQL。
+
+    /**
+     * Increase folder's note count when insert new note to the folder
+     */
+    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" +
+                    "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+                    " END";
+// 当向文件夹中插入新笔记时增加文件夹的笔记数量的触发器 SQL。
+
+    /**
+     * Decrease folder's note count when delete note from the folder
+     */
+    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" +
+                    "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+                    "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
+                    " END";
+// 当从文件夹中删除笔记时减少文件夹的笔记数量的触发器 SQL。
+
+    /**
+     * Update note's content when insert data with type {@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 + "'" +
+                    " BEGIN" +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+                    "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+                    " END";
+// 当插入数据类型为 DataConstants.NOTE 的数据时更新笔记内容的触发器 SQL。
+
+    /**
+     * Update note's content when data with {@link DataConstants#NOTE} type has changed
+     */
+    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 + "'" +
+                    " BEGIN" +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+                    "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+                    " END";
+// 当数据类型为 DataConstants.NOTE 的数据发生变化时更新笔记内容的触发器 SQL。
+
+    /**
+     * Update note's content when data with {@link DataConstants#NOTE} type has deleted
+     */
+    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 + "'" +
+                    " BEGIN" +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.SNIPPET + "=''" +
+                    "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
+                    " END";
+// 当数据类型为 DataConstants.NOTE 的数据被删除时更新笔记内容为空的触发器 SQL。
+
+    /**
+     * Delete datas belong to note which has been deleted
+     */
+    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 + ";" +
+                    " END";
+// 当笔记被删除时删除属于该笔记的数据的触发器 SQL。
+
+    /**
+     * Delete notes belong to folder which has been deleted
+     */
+    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 + ";" +
+                    " END";
+// 当文件夹被删除时删除属于该文件夹的笔记的触发器 SQL。
+
+    /**
+     * Move notes belong to folder which has been moved to trash folder
+     */
+    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
+            "CREATE TRIGGER folder_move_notes_on_trash " +
+                    " AFTER UPDATE ON " + TABLE.NOTE +
+                    " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+                    " BEGIN" +
+                    "  UPDATE " + TABLE.NOTE +
+                    "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+                    "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
+                    " END";
+// 当文件夹被移动到垃圾桶时，将属于该文件夹的笔记也移动到垃圾桶的触发器 SQL。
+
+    public NotesDatabaseHelper(Context context) {
+// 构造函数，传入上下文对象。
+        super(context, DB_NAME, null, DB_VERSION);
+// 调用父类构造函数，传入数据库名称、游标工厂和版本号。
+    }
+
+    public void createNoteTable(SQLiteDatabase db) {
+// 创建“note”表的方法。
+        db.execSQL(CREATE_NOTE_TABLE_SQL);
+// 执行创建“note”表的 SQL 语句。
+        reCreateNoteTableTriggers(db);
+// 重新创建“note”表的触发器。
+        createSystemFolder(db);
+// 创建系统文件夹。
+        Log.d(TAG, "note table has been created");
+// 输出日志，表明“note”表已创建。
+    }
+
+    private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+// 重新创建“note”表触发器的方法。
+        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);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+    }
+
+    private void createSystemFolder(SQLiteDatabase db) {
+// 创建系统文件夹的方法。
+        ContentValues values = new ContentValues();
+// 创建一个 ContentValues 对象，用于存储要插入数据库的值。
+
+        /**
+         * call record foler for call notes
+         */
+        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
+// 将特定值放入 ContentValues 中，用于插入记录文件夹。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将特定值放入 ContentValues 中，用于插入记录文件夹。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+
+        /**
+         * root folder which is default folder
+         */
+        values.clear();
+// 清空 ContentValues。
+        values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
+// 将特定值放入 ContentValues 中，用于插入根文件夹。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将特定值放入 ContentValues 中，用于插入根文件夹。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+
+        /**
+         * temporary folder which is used for moving note
+         */
+        values.clear();
+// 清空 ContentValues。
+        values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+// 将特定值放入 ContentValues 中，用于插入临时文件夹。
+        values.put        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将特定值放入 ContentValues 中，用于插入临时文件夹的类型为系统类型。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+
+        /**
+         * create trash folder
+         */
+        values.clear();
+// 清空 ContentValues。
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+// 将特定值放入 ContentValues 中，用于插入垃圾桶文件夹的 ID。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将特定值放入 ContentValues 中，用于插入垃圾桶文件夹的类型为系统类型。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+    }
+
+    public void createDataTable(SQLiteDatabase db) {
+// 创建“data”表的方法。
+        db.execSQL(CREATE_DATA_TABLE_SQL);
+// 执行创建“data”表的 SQL 语句。
+        reCreateDataTableTriggers(db);
+// 重新创建“data”表的触发器。
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
+// 创建“data”表中“note_id”索引。
+        Log.d(TAG, "data table has been created");
+// 输出日志，表明“data”表已创建。
+    }
+
+    private void reCreateDataTableTriggers(SQLiteDatabase db) {
+// 重新创建“data”表触发器的方法。
+        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);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
+// 执行创建新的触发器的 SQL 语句。
+    }
+
+    static synchronized NotesDatabaseHelper getInstance(Context context) {
+// 获取单例实例的静态方法。
+        if (mInstance == null) {
+// 如果单例实例为空。
+            mInstance = new NotesDatabaseHelper(context);
+// 创建一个新的 NotesDatabaseHelper 实例并赋值给单例实例。
+        }
+        return mInstance;
+// 返回单例实例。
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+// 重写 onCreate 方法，在数据库首次创建时被调用。
+        createNoteTable(db);
+// 创建“note”表。
+        createDataTable(db);
+// 创建“data”表。
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+// 重写 onUpgrade 方法，在数据库版本升级时被调用。
+        boolean reCreateTriggers = false;
+// 标记是否需要重新创建触发器。
+        boolean skipV2 = false;
+// 标记是否跳过版本 2 的升级步骤。
+
+        if (oldVersion == 1) {
+// 如果当前数据库版本为 1。
+            upgradeToV2(db);
+// 执行升级到版本 2 的方法。
+            skipV2 = true; // this upgrade including the upgrade from v2 to v3
+// 设置跳过版本 2 的标记为 true，表示这个升级包含了从版本 2 到版本 3 的升级步骤。
+            oldVersion++;
+// 将旧版本号加 1。
+        }
+
+        if (oldVersion == 2 &&!skipV2) {
+// 如果当前数据库版本为 2 且没有跳过版本 2 的升级步骤。
+            upgradeToV3(db);
+// 执行升级到版本 3 的方法。
+            reCreateTriggers = true;
+// 设置需要重新创建触发器的标记为 true。
+            oldVersion++;
+// 将旧版本号加 1。
+        }
+
+        if (oldVersion == 3) {
+// 如果当前数据库版本为 3。
+            upgradeToV4(db);
+// 执行升级到版本 4 的方法。
+            oldVersion++;
+// 将旧版本号加 1。
+        }
+
+        if (reCreateTriggers) {
+// 如果需要重新创建触发器。
+            reCreateNoteTableTriggers(db);
+// 重新创建“note”表的触发器。
+            reCreateDataTableTriggers(db);
+// 重新创建“data”表的触发器。
+        }
+
+        if (oldVersion!= newVersion) {
+// 如果旧版本号与新版本号不相等。
+            throw new IllegalStateException("Upgrade notes database to version " + newVersion
+                    + "fails");
+// 抛出异常，表示数据库升级失败。
+        }
+    }
+
+    private void upgradeToV2(SQLiteDatabase db) {
+// 升级到版本 2 的方法。
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
+// 如果存在“note”表，则删除它。
+        db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+// 如果存在“data”表，则删除它。
+        createNoteTable(db);
+// 创建“note”表。
+        createDataTable(db);
+// 创建“data”表。
+    }
+
+    private void upgradeToV3(SQLiteDatabase db) {
+// 升级到版本 3 的方法。
+        // drop unused triggers
+        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");
+// 删除未使用的触发器（如果存在）。
+        // add a column for gtask id
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+                + " TEXT NOT NULL DEFAULT ''");
+// 在“note”表中添加一个用于存储 gtask id 的列。
+        // add a trash system folder
+        ContentValues values = new ContentValues();
+// 创建一个 ContentValues 对象，用于存储要插入数据库的值。
+        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+// 将垃圾桶文件夹的 ID 放入 ContentValues 中。
+        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将垃圾桶文件夹的类型为系统类型放入 ContentValues 中。
+        db.insert(TABLE.NOTE, null, values);
+// 将数据插入“note”表。
+    }
+
+    private void upgradeToV4(SQLiteDatabase db) {
+// 升级到版本 4 的方法。
+        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+                + " INTEGER NOT NULL DEFAULT 0");
+// 在“note”表中添加一个版本号列。
+    }
+}

src/net/micode/notes/data/NotesProvider.java

@@ -0,0 +1,547 @@
+/*
+ * 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.
+ */
+
+// 版权声明：2010 - 2011 年，MiCode 开源社区（www.micode.net）。
+// 在 Apache License 2.0 协议下授权；你不得在不符合该协议的情况下使用此文件。你可以在以下地址获取该协议的副本：http://www.apache.org/licenses/LICENSE-2.0。
+// 除非适用法律要求或书面同意，否则根据本许可证分发的软件是基于“按原样”基础提供的，不附带任何明示或暗示的保证或条件。请参阅许可证以了解管理权限和限制的特定语言。
+
+package net.micode.notes.data;
+
+import android.app.SearchManager;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+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 {
+// 定义公共类 NotesProvider，继承自 ContentProvider。
+
+    private static final UriMatcher mMatcher;
+    // 定义静态的 UriMatcher 对象 mMatcher。
+
+    private NotesDatabaseHelper mHelper;
+    // 定义 NotesDatabaseHelper 对象 mHelper。
+
+    private static final String TAG = "NotesProvider";
+    // 定义静态常量 TAG，值为“NotesProvider”。
+
+    private static final int URI_NOTE = 1;
+    // 定义常量 URI_NOTE，值为 1。
+
+    private static final int URI_NOTE_ITEM = 2;
+    // 定义常量 URI_NOTE_ITEM，值为 2。
+
+    private static final int URI_DATA = 3;
+    // 定义常量 URI_DATA，值为 3。
+
+    private static final int URI_DATA_ITEM = 4;
+    // 定义常量 URI_DATA_ITEM，值为 4。
+
+    private static final int URI_SEARCH = 5;
+    // 定义常量 URI_SEARCH，值为 5。
+
+    private static final int URI_SEARCH_SUGGEST = 6;
+    // 定义常量 URI_SEARCH_SUGGEST，值为 6。
+
+    static {
+    // 静态初始化块。
+
+        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        // 创建一个新的 UriMatcher 对象，并设置初始匹配结果为 UriMatcher.NO_MATCH。
+
+        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
+        // 将 Uri “content://micode_notes/note” 与常量 URI_NOTE 关联。
+
+        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
+        // 将 Uri “content://micode_notes/note/[ID]” 与常量 URI_NOTE_ITEM 关联。
+
+        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
+        // 将 Uri “content://micode_notes/data” 与常量 URI_DATA 关联。
+
+        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
+        // 将 Uri “content://micode_notes/data/[ID]” 与常量 URI_DATA_ITEM 关联。
+
+        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
+        // 将 Uri “content://micode_notes/search” 与常量 URI_SEARCH 关联。
+
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
+        // 将 Uri “content://micode_notes/search_query”（根据 SearchManager.SUGGEST_URI_PATH_QUERY）与常量 URI_SEARCH_SUGGEST 关联。
+
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
+        // 将 Uri “content://micode_notes/search_query/[SEARCH_STRING]”（根据 SearchManager.SUGGEST_URI_PATH_QUERY 和通配符）与常量 URI_SEARCH_SUGGEST 关联。
+
+    }
+
+    /**
+     * x'0A' represents the '\n' character in sqlite. For title and content in the search result,
+     * we will trim '\n' and white space in order to show more information.
+     */
+    // 注释说明以下字符串常量的用途。
+
+    private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+            + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
+            + "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 + ","
+            + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
+    // 定义常量 NOTES_SEARCH_PROJECTION，用于搜索结果中的投影列。
+
+    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;
+    // 定义常量 NOTES_SNIPPET_SEARCH_QUERY，用于搜索笔记片段的查询语句。
+
+    @Override
+    public boolean onCreate() {
+    // 重写 onCreate 方法。
+
+        mHelper = NotesDatabaseHelper.getInstance(getContext());
+        // 获取 NotesDatabaseHelper 的实例。
+
+        return true;
+        // 返回 true，表示创建成功。
+
+    }
+
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+                        String sortOrder) {
+    // 重写 query 方法，用于查询数据。
+
+        Cursor c = null;
+        // 定义游标对象 c，并初始化为 null。
+
+        SQLiteDatabase db = mHelper.getReadableDatabase();
+        // 获取可读的 SQLiteDatabase 对象。
+
+        String id = null;
+        // 定义字符串 id，初始化为 null。
+
+        switch (mMatcher.match(uri)) {
+        // 根据 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);
+                // 获取笔记的 ID。
+
+                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
+                // 根据 ID 查询单个笔记。
+
+                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);
+                // 获取数据的 ID。
+
+                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
+                // 根据 ID 查询单个数据。
+
+                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;
+                // 定义字符串 searchString，初始化为 null。
+
+                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
+                // 如果是搜索建议的 Uri。
+
+                    if (uri.getPathSegments().size() > 1) {
+                    // 如果路径段数量大于 1。
+
+                        searchString = uri.getPathSegments().get(1);
+                        // 获取搜索字符串。
+
+                    }
+                } else {
+                // 否则是普通搜索的 Uri。
+
+                    searchString = uri.getQueryParameter("pattern");
+                    // 从查询参数中获取搜索字符串。
+
+                }
+
+                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) {
+        // 如果游标不为 null。
+
+            c.setNotificationUri(getContext().getContentResolver(), uri);
+            // 设置通知 Uri。
+
+        }
+        return c;
+        // 返回游标。
+
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+    // 重写 insert 方法，用于插入数据。
+
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 获取可写的 SQLiteDatabase 对象。
+
+        long dataId = 0, noteId = 0, insertedId = 0;
+        // 定义长整型变量 dataId、noteId 和 insertedId，并初始化为 0。
+
+        switch (mMatcher.match(uri)) {
+        // 根据 Uri 匹配结果进行分支处理。
+
+            case URI_NOTE:
+                insertedId = noteId = db.insert(TABLE.NOTE, null, values);
+                // 插入笔记。
+
+                break;
+            case URI_DATA:
+                if (values.containsKey(DataColumns.NOTE_ID)) {
+                // 如果 ContentValues 中包含 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 不匹配任何已知的情况，抛出异常。
+
+        }
+        // Notify the note uri
+        if (noteId > 0) {
+        // 如果笔记 ID 大于 0。
+
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
+            // 通知笔记 Uri 的更改。
+
+        }
+
+        // Notify the data uri
+        if (dataId > 0) {
+        // 如果数据 ID 大于 0。
+
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
+            // 通知数据 Uri 的更改。
+
+        }
+
+        return ContentUris.withAppendedId(uri, insertedId);
+        // 返回插入后的 Uri。
+
+    }
+
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+    // 重写 delete 方法，用于删除数据。
+
+        int count = 0;
+        // 定义整型变量 count，初始化为 0。
+
+        String id = null;
+        // 定义字符串 id，初始化为 null。
+
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 获取可写的 SQLiteDatabase 对象。
+
+        boolean deleteData = false;
+        // 定义布尔变量 deleteData，初始化为 false。
+
+        switch (mMatcher.match(uri)) {
+        // 根据 Uri 匹配结果进行分支处理。
+
+            case URI_NOTE:
+                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
+                count = db.delete(TABLE.NOTE, selection, selectionArgs);
+                // 删除笔记，添加条件 ID 大于 0。
+
+                break;
+            case URI_NOTE_ITEM:
+                id = uri.getPathSegments().get(1);
+                // 获取笔记的 ID。
+
+                /**
+                 * ID that smaller than 0 is system folder which is not allowed to
+                 * trash
+                 */
+                // 注释说明小于 0 的 ID 是系统文件夹，不允许删除。
+
+                long noteId = Long.valueOf(id);
+                // 将 ID 转换为长整型。
+
+                if (noteId <= 0) {
+                // 如果笔记 ID 小于等于 0。
+
+                    break;
+                    // 跳出循环。
+
+                }
+                count = db.delete(TABLE.NOTE,
+                        NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+                // 删除单个笔记。
+
+                break;
+            case URI_DATA:
+                count = db.delete(TABLE.DATA, selection, selectionArgs);
+                deleteData = true;
+                // 删除数据，设置 deleteData 为 true。
+
+                break;
+            case URI_DATA_ITEM:
+                id = uri.getPathSegments().get(1);
+                // 获取数据的 ID。
+
+                count = db.delete(TABLE.DATA,
+                        DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+                deleteData = true;
+                // 删除单个数据，设置 deleteData 为 true。
+
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri);
+                // 如果 Uri 不匹配任何已知的情况，抛出异常。
+
+        }
+        if (count > 0) {
+        // 如果删除的数量大于 0。
+
+            if (deleteData) {
+            // 如果删除的是数据。
+
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
+                // 通知笔记 Uri 的更改。
+
+            }
+            getContext().getContentResolver().notifyChange(uri, null);
+            // 通知当前 Uri 的更改。
+
+        }
+        return count;
+        // 返回删除的数量。
+
+    }
+
+    @Override
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+    // 重写 update 方法，用于更新数据。
+
+        int count = 0;
+        // 定义整型变量 count，初始化为 0。
+
+        String id = null;
+        // 定义字符串 id，初始化为 null。
+
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 获取可写的 SQLiteDatabase 对象。
+
+        boolean updateData = false;
+        // 定义布尔变量 updateData，初始化为 false。
+
+        switch (mMatcher.match(uri)) {
+        // 根据 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);
+                // 获取笔记的 ID。
+
+                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
+                // 更新指定笔记的版本号。
+
+                count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs);
+                // 更新单个笔记。
+
+                break;
+            case URI_DATA:
+                count = db.update(TABLE.DATA, values, selection, selectionArgs);
+                updateData = true;
+                // 更新数据，设置 updateData 为 true。
+
+                break;
+            case URI_DATA_ITEM:
+                id = uri.getPathSegments().get(1);
+                // 获取数据的 ID。
+
+                count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs);
+                updateData = true;
+                // 更新单个数据，设置 updateData 为 true。
+
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown URI " + uri);
+                // 如果 Uri 不匹配任何已知的情况，抛出
+}
+        if (count > 0) {
+// 如果更新操作影响的记录数大于 0。
+            if (updateData) {
+// 如果更新了数据记录。
+                // 如果更新了数据记录，则通知监听器。
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
+// 获取上下文环境，通过内容解析器通知与笔记内容相关的监听器（Notes.CONTENT_NOTE_URI）数据发生了变化，第二个参数为 null 表示没有额外的通知数据。
+            }
+            // 通知监听器指定的 URI 发生了变化。
+            getContext().getContentResolver().notifyChange(uri, null);
+// 获取上下文环境，通过内容解析器通知本次更新操作对应的 URI（uri）的数据发生了变化，第二个参数为 null 表示没有额外的通知数据。
+        }
+        return count;
+// 返回更新操作所影响的记录数。
+
+    }
+
+// 解析选择条件的方法。
+private String parseSelection(String selection) {
+// 定义一个私有方法，接收一个选择条件字符串参数。
+    return (!TextUtils.isEmpty(selection)? " AND (" + selection + ')' : "");
+// 如果选择条件字符串不为空，返回在其前后加上“ AND (”和“)”的字符串；如果为空，返回空字符串。
+}
+
+// 增加笔记版本号的方法。
+private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+// 定义一个私有方法，接收笔记的 ID、选择条件字符串和选择条件参数数组。
+    StringBuilder sql = new StringBuilder(120);
+// 创建一个 StringBuilder 对象，用于构建 SQL 语句，初始容量为 120。
+    sql.append("UPDATE ");
+// 在 StringBuilder 中添加“UPDATE ”。
+    sql.append(TABLE.NOTE);
+// 添加表名 TABLE.NOTE。
+    sql.append(" SET ");
+// 添加“ SET ”。
+    sql.append(NoteColumns.VERSION);
+// 添加版本号列名 NoteColumns.VERSION。
+    sql.append("=" + NoteColumns.VERSION + "+1 ");
+// 添加版本号设置的 SQL 片段，将版本号设置为当前版本号加 1。
+
+    if (id > 0 ||!TextUtils.isEmpty(selection)) {
+// 如果传入的 ID 大于 0 或者选择条件字符串不为空。
+        sql.append(" WHERE ");
+// 在 StringBuilder 中添加“ WHERE ”。
+    }
+    if (id > 0) {
+// 如果传入的 ID 大于 0。
+        sql.append(NoteColumns.ID + "=" + String.valueOf(id));
+// 添加笔记 ID 的条件到 StringBuilder 中。
+    }
+    if (!TextUtils.isEmpty(selection)) {
+// 如果选择条件字符串不为空。
+        String selectString = id > 0? parseSelection(selection) : selection;
+// 如果 ID 大于 0，调用 parseSelection 方法处理选择条件字符串；否则直接使用选择条件字符串。
+        for (String args : selectionArgs) {
+// 遍历选择条件参数数组。
+            selectString = selectString.replaceFirst("\\?", args);
+// 将选择条件字符串中的第一个占位符替换为当前参数值。
+        }
+        sql.append(selectString);
+// 将处理后的选择条件字符串添加到 StringBuilder 中。
+    }
+
+    mHelper.getWritableDatabase().execSQL(sql.toString());
+// 使用数据库帮助类 mHelper 的可写数据库执行构建好的 SQL 语句。
+
+}
+
+// 内容提供器的 getType 方法，用于返回指定 URI 的 MIME 类型。
+@Override
+public String getType(Uri uri) {
+// 重写内容提供器的 getType 方法，接收一个 URI 参数。
+    // TODO Auto-generated method stub
+// 这里是一个待实现的方法注释。
+    return null;
+// 返回 null，表示当前未实现该方法。
+}
+}

src/net/micode/notes/gtask/data/MetaData.java

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * （版权所有（c）2010 - 2011，MiCode 开源社区（www.micode.net））
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * （根据 Apache License 2.0 版（“许可证”）获得许可；）
+ * 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
+ * （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.gtask.data;
+// 包 net.micode.notes.gtask.data;（包名为 net.micode.notes.gtask.data；）
+
+import android.database.Cursor;
+// 导入 android.database.Cursor；（导入 Android 的数据库游标类；）
+import android.util.Log;
+// 导入 android.util.Log；（导入 Android 的日志工具类；）
+
+import net.micode.notes.tool.GTaskStringUtils;
+// 导入 net.micode.notes.tool.GTaskStringUtils；（导入来自 net.micode.notes.tool 的 GTaskStringUtils 类；）
+
+import org.json.JSONException;
+// 导入 org.json.JSONException；（导入 JSON 处理的异常类；）
+import org.json.JSONObject;
+// 导入 org.json.JSONObject；（导入 JSON 对象类；）
+
+
+public class MetaData extends Task {
+// 公共类 MetaData 继承自 Task；（定义一个名为 MetaData 的公共类，它继承自 Task 类；）
+    private final static String TAG = MetaData.class.getSimpleName();
+// 私有最终静态字符串变量 TAG，赋值为 MetaData 类的简单名称；（定义一个私有最终静态的字符串变量 TAG，值为 MetaData 类的简单名称；）
+
+    private String mRelatedGid = null;
+// 私有字符串变量 mRelatedGid，初始值为 null；（定义一个私有字符串变量 mRelatedGid，初始值为 null；）
+
+    public void setMeta(String gid, JSONObject metaInfo) {
+// 公共方法 setMeta，接收字符串 gid 和 JSON 对象 metaInfo；（定义一个名为 setMeta 的公共方法，接收一个字符串 gid 和一个 JSONObject 对象 metaInfo；）
+        try {
+// 尝试执行以下代码块；（开始 try 代码块；）
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
+// 将 gid 放入 metaInfo 的特定键中；（尝试将 gid 放入 metaInfo 对象中，键为 GTaskStringUtils.META_HEAD_GTASK_ID；）
+        } catch (JSONException e) {
+// 如果发生 JSON 异常，进入此代码块；（捕获 JSONException 异常；）
+            Log.e(TAG, "failed to put related gid");
+// 输出错误日志；（打印错误日志，提示“failed to put related gid”；）
+        }
+        setNotes(metaInfo.toString());
+// 设置 notes 属性；（设置当前对象的 notes 属性为 metaInfo 的字符串表示形式；）
+        setName(GTaskStringUtils.META_NOTE_NAME);
+// 设置 name 属性；（设置当前对象的 name 属性为 GTaskStringUtils.META_NOTE_NAME；）
+    }
+
+    public String getRelatedGid() {
+// 公共方法 getRelatedGid；（定义一个名为 getRelatedGid 的公共方法；）
+        return mRelatedGid;
+// 返回 mRelatedGid；（返回 mRelatedGid 的值；）
+    }
+
+    @Override
+    public boolean isWorthSaving() {
+// 重写方法 isWorthSaving；（重写父类的 isWorthSaving 方法；）
+        return getNotes()!= null;
+// 返回 notes 属性不为 null 的判断结果；（返回当前对象的 notes 属性不为 null 的判断结果；）
+    }
+
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) {
+// 重写方法 setContentByRemoteJSON；（重写父类的 setContentByRemoteJSON 方法；）
+        super.setContentByRemoteJSON(js);
+// 调用父类的同名方法；（先调用父类的 setContentByRemoteJSON 方法；）
+        if (getNotes()!= null) {
+// 如果 notes 属性不为 null；（如果当前对象的 notes 属性不为 null；）
+            try {
+// 尝试执行以下代码块；（开始 try 代码块；）
+                JSONObject metaInfo = new JSONObject(getNotes().trim());
+// 创建一个新的 JSON 对象，从 notes 属性的字符串表示形式中获取；（从当前对象的 notes 属性的字符串表示形式中创建一个新的 JSONObject 对象；）
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
+// 获取相关的 gid；（从新创建的 JSONObject 对象中获取特定键的值，并赋值给 mRelatedGid；）
+            } catch (JSONException e) {
+// 如果发生 JSON 异常，进入此代码块；（捕获 JSONException 异常；）
+                Log.w(TAG, "failed to get related gid");
+// 输出警告日志；（打印警告日志，提示“failed to get related gid”；）
+                mRelatedGid = null;
+// 将 mRelatedGid 设为 null；（将 mRelatedGid 设为 null；）
+            }
+        }
+    }
+
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {
+// 重写方法 setContentByLocalJSON；（重写父类的 setContentByLocalJSON 方法；）
+        // this function should not be called
+// 此函数不应被调用；（注释说明这个函数不应该被调用；）
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
+// 抛出非法访问错误；（抛出 IllegalAccessError 异常，提示“MetaData:setContentByLocalJSON should not be called”；）
+    }
+
+    @Override
+    public JSONObject getLocalJSONFromContent() {
+// 重写方法 getLocalJSONFromContent；（重写父类的 getLocalJSONFromContent 方法；）
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
+// 抛出非法访问错误；（抛出 IllegalAccessError 异常，提示“MetaData:getLocalJSONFromContent should not be called”；）
+    }
+
+    @Override
+    public int getSyncAction(Cursor c) {
+// 重写方法 getSyncAction；（重写父类的 getSyncAction 方法；）
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
+// 抛出非法访问错误；（抛出 IllegalAccessError 异常，提示“MetaData:getSyncAction should not be called”；）
+    }
+
+}

src/net/micode/notes/gtask/data/Node.java

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * （版权所有（c）2010 - 2011，MiCode 开源社区（www.micode.net））
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * （根据 Apache License 2.0 版（“许可证”）获得许可；）
+ * 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
+ * （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.gtask.data;
+// 包 net.micode.notes.gtask.data;（包名为 net.micode.notes.gtask.data；）
+
+import android.database.Cursor;
+// 导入 android.database.Cursor；（导入 Android 的数据库游标类；）
+
+import org.json.JSONObject;
+// 导入 org.json.JSONObject；（导入 JSON 对象类；）
+
+public abstract class Node {
+// 公共抽象类 Node；（定义一个名为 Node 的公共抽象类；）
+    public static final int SYNC_ACTION_NONE = 0;
+// 公共静态最终整型变量 SYNC_ACTION_NONE，赋值为 0；（定义一个公共静态最终的整型变量 SYNC_ACTION_NONE，值为 0；）
+
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;
+// 公共静态最终整型变量 SYNC_ACTION_ADD_REMOTE，赋值为 1；（定义一个公共静态最终的整型变量 SYNC_ACTION_ADD_REMOTE，值为 1；）
+
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;
+// 公共静态最终整型变量 SYNC_ACTION_ADD_LOCAL，赋值为 2；（定义一个公共静态最终的整型变量 SYNC_ACTION_ADD_LOCAL，值为 2；）
+
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;
+// 公共静态最终整型变量 SYNC_ACTION_DEL_REMOTE，赋值为 3；（定义一个公共静态最终的整型变量 SYNC_ACTION_DEL_REMOTE，值为 3；）
+
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;
+// 公共静态最终整型变量 SYNC_ACTION_DEL_LOCAL，赋值为 4；（定义一个公共静态最终的整型变量 SYNC_ACTION_DEL_LOCAL，值为 4；）
+
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
+// 公共静态最终整型变量 SYNC_ACTION_UPDATE_REMOTE，赋值为 5；（定义一个公共静态最终的整型变量 SYNC_ACTION_UPDATE_REMOTE，值为 5；）
+
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
+// 公共静态最终整型变量 SYNC_ACTION_UPDATE_LOCAL，赋值为 6；（定义一个公共静态最终的整型变量 SYNC_ACTION_UPDATE_LOCAL，值为 6；）
+
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
+// 公共静态最终整型变量 SYNC_ACTION_UPDATE_CONFLICT，赋值为 7；（定义一个公共静态最终的整型变量 SYNC_ACTION_UPDATE_CONFLICT，值为 7；）
+
+    public static final int SYNC_ACTION_ERROR = 8;
+// 公共静态最终整型变量 SYNC_ACTION_ERROR，赋值为 8；（定义一个公共静态最终的整型变量 SYNC_ACTION_ERROR，值为 8；）
+
+    private String mGid;
+// 私有字符串变量 mGid；（定义一个私有字符串变量 mGid；）
+
+    private String mName;
+// 私有字符串变量 mName；（定义一个私有字符串变量 mName；）
+
+    private long mLastModified;
+// 私有长整型变量 mLastModified；（定义一个私有长整型变量 mLastModified；）
+
+    private boolean mDeleted;
+// 私有布尔型变量 mDeleted；（定义一个私有布尔型变量 mDeleted；）
+
+    public Node() {
+// 公共构造函数；（定义一个公共的构造函数；）
+        mGid = null;
+// 初始化 mGid 为 null；（将 mGid 初始化为 null；）
+        mName = "";
+// 初始化 mName 为空字符串；（将 mName 初始化为空字符串；）
+        mLastModified = 0;
+// 初始化 mLastModified 为 0；（将 mLastModified 初始化为 0；）
+        mDeleted = false;
+// 初始化 mDeleted 为 false；（将 mDeleted 初始化为 false；）
+    }
+
+    public abstract JSONObject getCreateAction(int actionId);
+// 公共抽象方法 getCreateAction，接收整型参数 actionId；（定义一个公共抽象方法 getCreateAction，接收一个整型参数 actionId，返回一个 JSONObject 对象；）
+
+    public abstract JSONObject getUpdateAction(int actionId);
+// 公共抽象方法 getUpdateAction，接收整型参数 actionId；（定义一个公共抽象方法 getUpdateAction，接收一个整型参数 actionId，返回一个 JSONObject 对象；）
+
+    public abstract void setContentByRemoteJSON(JSONObject js);
+// 公共抽象方法 setContentByRemoteJSON，接收 JSONObject 参数 js；（定义一个公共抽象方法 setContentByRemoteJSON，接收一个 JSONObject 参数 js；）
+
+    public abstract void setContentByLocalJSON(JSONObject js);
+// 公共抽象方法 setContentByLocalJSON，接收 JSONObject 参数 js；（定义一个公共抽象方法 setContentByLocalJSON，接收一个 JSONObject 参数 js；）
+
+    public abstract JSONObject getLocalJSONFromContent();
+// 公共抽象方法 getLocalJSONFromContent；（定义一个公共抽象方法 getLocalJSONFromContent，返回一个 JSONObject 对象；）
+
+    public abstract int getSyncAction(Cursor c);
+// 公共抽象方法 getSyncAction，接收 Cursor 参数 c；（定义一个公共抽象方法 getSyncAction，接收一个 Cursor 参数 c，返回一个整型值；）
+
+    public void setGid(String gid) {
+// 公共方法 setGid，接收字符串参数 gid；（定义一个名为 setGid 的公共方法，接收一个字符串参数 gid；）
+        this.mGid = gid;
+// 设置 mGid 的值；（将 this.mGid 赋值为 gid；）
+    }
+
+    public void setName(String name) {
+// 公共方法 setName，接收字符串参数 name；（定义一个名为 setName 的公共方法，接收一个字符串参数 name；）
+        this.mName = name;
+// 设置 mName 的值；（将 this.mName 赋值为 name；）
+    }
+
+    public void setLastModified(long lastModified) {
+// 公共方法 setLastModified，接收长整型参数 lastModified；（定义一个名为 setLastModified 的公共方法，接收一个长整型参数 lastModified；）
+        this.mLastModified = lastModified;
+// 设置 mLastModified 的值；（将 this.mLastModified 赋值为 lastModified；）
+    }
+
+    public void setDeleted(boolean deleted) {
+// 公共方法 setDeleted，接收布尔型参数 deleted；（定义一个名为 setDeleted 的公共方法，接收一个布尔型参数 deleted；）
+        this.mDeleted = deleted;
+// 设置 mDeleted 的值；（将 this.mDeleted 赋值为 deleted；）
+    }
+
+    public String getGid() {
+// 公共方法 getGid；（定义一个名为 getGid 的公共方法；）
+        return this.mGid;
+// 返回 mGid 的值；（返回 this.mGid 的值；）
+    }
+
+    public String getName() {
+// 公共方法 getName；（定义一个名为 getName 的公共方法；）
+        return this.mName;
+// 返回 mName 的值；（返回 this.mName 的值；）
+    }
+
+    public long getLastModified() {
+// 公共方法 getLastModified；（定义一个名为 getLastModified 的公共方法；）
+        return this.mLastModified;
+// 返回 mLastModified 的值；（返回 this.mLastModified 的值；）
+    }
+
+    public boolean getDeleted() {
+// 公共方法 getDeleted；（定义一个名为 getDeleted 的公共方法；）
+        return this.mDeleted;
+// 返回 mDeleted 的值；（返回 this.mDeleted 的值；）
+    }
+
+}

src/net/micode/notes/gtask/data/SqlData.java

@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) 2010 - 2011, The MiCode Open Source Community (www.micode.net)
+ * （版权所有（c）2010 - 2011，MiCode 开源社区（www.micode.net）。）
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * （根据 Apache License 2.0 版（“许可证”）获得许可；）
+ * 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
+ * （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.gtask.data;
+// 包 net.micode.notes.gtask.data；（这个包的名字是 net.micode.notes.gtask.data。）
+
+import android.content.ContentResolver;
+// 导入 android.content.ContentResolver；（导入 Android 的内容解析器类。）
+import android.content.ContentUris;
+// 导入 android.content.ContentUris；（导入 Android 的内容 URI 工具类。）
+import android.content.ContentValues;
+// 导入 android.content.ContentValues；（导入 Android 的内容值类。）
+import android.content.Context;
+// 导入 android.content.Context；（导入 Android 的上下文类。）
+import android.database.Cursor;
+// 导入 android.database.Cursor；（导入 Android 的数据库游标类。）
+import android.net.Uri;
+// 导入 android.net.Uri；（导入 Android 的统一资源标识符类。）
+import android.util.Log;
+// 导入 android.util.Log；（导入 Android 的日志工具类。）
+
+import net.micode.notes.data.Notes;
+// 导入 net.micode.notes.data.Notes；（导入来自 net.micode.notes.data 的 Notes 类。）
+import net.micode.notes.data.Notes.DataColumns;
+// 导入 net.micode.notes.data.Notes.DataColumns；（导入 Notes 类中的数据列类。）
+import net.micode.notes.data.Notes.DataConstants;
+// 导入 net.micode.notes.data.Notes.DataConstants；（导入 Notes 类中的数据常量类。）
+import net.micode.notes.data.Notes.NoteColumns;
+// 导入 net.micode.notes.data.Notes.NoteColumns；（导入 Notes 类中的笔记列类。）
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+// 导入 net.micode.notes.data.NotesDatabaseHelper.TABLE；（导入 Notes 数据库助手类中的表枚举。）
+import net.micode.notes.gtask.exception.ActionFailureException;
+// 导入 net.micode.notes.gtask.exception.ActionFailureException；（导入特定的异常类。）
+
+import org.json.JSONException;
+// 导入 org.json.JSONException；（导入 JSON 处理的异常类。）
+import org.json.JSONObject;
+// 导入 org.json.JSONObject；（导入 JSON 对象类。）
+
+
+public class SqlData {
+// 公共类 SqlData；（定义一个名为 SqlData 的公共类。）
+    private static final String TAG = SqlData.class.getSimpleName();
+// 私有静态最终字符串变量 TAG，赋值为 SqlData 类的简单名称；（定义一个私有静态最终的字符串变量 TAG，值为 SqlData 类的简单名称。）
+
+    private static final int INVALID_ID = -99999;
+// 私有静态最终整型变量 INVALID_ID，赋值为 -99999；（定义一个私有静态最终的整型变量 INVALID_ID，值为 -99999。）
+
+    public static final String[] PROJECTION_DATA = new String[] {
+            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+            DataColumns.DATA3
+    };
+// 公共静态最终字符串数组变量 PROJECTION_DATA；（定义一个公共静态最终的字符串数组变量 PROJECTION_DATA，包含特定的数据列名称。）
+
+    public static final int DATA_ID_COLUMN = 0;
+// 公共静态最终整型变量 DATA_ID_COLUMN，赋值为 0；（定义一个公共静态最终的整型变量 DATA_ID_COLUMN，值为 0。）
+
+    public static final int DATA_MIME_TYPE_COLUMN = 1;
+// 公共静态最终整型变量 DATA_MIME_TYPE_COLUMN，赋值为 1；（定义一个公共静态最终的整型变量 DATA_MIME_TYPE_COLUMN，值为 1。）
+
+    public static final int DATA_CONTENT_COLUMN = 2;
+// 公共静态最终整型变量 DATA_CONTENT_COLUMN，赋值为 2；（定义一个公共静态最终的整型变量 DATA_CONTENT_COLUMN，值为 2。）
+
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+// 公共静态最终整型变量 DATA_CONTENT_DATA_1_COLUMN，赋值为 3；（定义一个公共静态最终的整型变量 DATA_CONTENT_DATA_1_COLUMN，值为 3。）
+
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+// 公共静态最终整型变量 DATA_CONTENT_DATA_3_COLUMN，赋值为 4；（定义一个公共静态最终的整型变量 DATA_CONTENT_DATA_3_COLUMN，值为 4。）
+
+    private ContentResolver mContentResolver;
+// 私有 ContentResolver 变量 mContentResolver；（定义一个私有变量 mContentResolver，类型为 ContentResolver。）
+
+    private boolean mIsCreate;
+// 私有布尔型变量 mIsCreate；（定义一个私有布尔型变量 mIsCreate。）
+
+    private long mDataId;
+// 私有长整型变量 mDataId；（定义一个私有长整型变量 mDataId。）
+
+    private String mDataMimeType;
+// 私有字符串变量 mDataMimeType；（定义一个私有字符串变量 mDataMimeType。）
+
+    private String mDataContent;
+// 私有字符串变量 mDataContent；（定义一个私有字符串变量 mDataContent。）
+
+    private long mDataContentData1;
+// 私有长整型变量 mDataContentData1；（定义一个私有长整型变量 mDataContentData1。）
+
+    private String mDataContentData3;
+// 私有字符串变量 mDataContentData3；（定义一个私有字符串变量 mDataContentData3。）
+
+    private ContentValues mDiffDataValues;
+// 私有 ContentValues 变量 mDiffDataValues；（定义一个私有变量 mDiffDataValues，类型为 ContentValues。）
+
+    public SqlData(Context context) {
+// 公共构造函数，接收 Context 参数；（定义一个公共构造函数，接收一个 Context 参数。）
+        mContentResolver = context.getContentResolver();
+// 获取内容解析器；（将 context 的内容解析器赋值给 mContentResolver。）
+        mIsCreate = true;
+// 设置创建标志；（将 mIsCreate 设置为 true。）
+        mDataId = INVALID_ID;
+// 初始化数据 ID；（将 mDataId 初始化为 INVALID_ID。）
+        mDataMimeType = DataConstants.NOTE;
+// 初始化数据 MIME 类型；（将 mDataMimeType 初始化为 DataConstants.NOTE。）
+        mDataContent = "";
+// 初始化数据内容；（将 mDataContent 初始化为空字符串。）
+        mDataContentData1 = 0;
+// 初始化数据内容数据 1；（将 mDataContentData1 初始化为 0。）
+        mDataContentData3 = "";
+// 初始化数据内容数据 3；（将 mDataContentData3 初始化为空字符串。）
+        mDiffDataValues = new ContentValues();
+// 创建新的 ContentValues 对象；（创建一个新的 ContentValues 对象并赋值给 mDiffDataValues。）
+    }
+
+    public SqlData(Context context, Cursor c) {
+// 公共构造函数，接收 Context 和 Cursor 参数；（定义一个公共构造函数，接收一个 Context 参数和一个 Cursor 参数。）
+        mContentResolver = context.getContentResolver();
+// 获取内容解析器；（将 context 的内容解析器赋值给 mContentResolver。）
+        mIsCreate = false;
+// 设置创建标志；（将 mIsCreate 设置为 false。）
+        loadFromCursor(c);
+// 从游标加载数据；（调用 loadFromCursor 方法，从传入的游标中加载数据。）
+        mDiffDataValues = new ContentValues();
+// 创建新的 ContentValues 对象；（创建一个新的 ContentValues 对象并赋值给 mDiffDataValues。）
+    }
+
+    private void loadFromCursor(Cursor c) {
+// 私有方法 loadFromCursor，接收 Cursor 参数；（定义一个私有方法 loadFromCursor，接收一个 Cursor 参数。）
+        mDataId = c.getLong(DATA_ID_COLUMN);
+// 获取数据 ID；（从游标中获取指定列的数据 ID，并赋值给 mDataId。）
+        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+// 获取数据 MIME 类型；（从游标中获取指定列的数据 MIME 类型，并赋值给 mDataMimeType。）
+        mDataContent = c.getString(DATA_CONTENT_COLUMN);
+// 获取数据内容；（从游标中获取指定列的数据内容，并赋值给 mDataContent。）
+        mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
+// 获取数据内容数据 1；（从游标中获取指定列的数据内容数据 1，并赋值给 mDataContentData1。）
+        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
+// 获取数据内容数据 3；（从游标中获取指定列的数据内容数据 3，并赋值给 mDataContentData3。）
+    }
+
+    public void setContent(JSONObject js) throws JSONException {
+// 公共方法 setContent，接收 JSONObject 参数；（定义一个公共方法 setContent，接收一个 JSONObject 参数。）
+        long dataId = js.has(DataColumns.ID)? js.getLong(DataColumns.ID) : INVALID_ID;
+// 获取数据 ID；（如果 JSONObject 中包含指定键，则获取对应的值作为数据 ID，否则设置为 INVALID_ID。）
+        if (mIsCreate || mDataId!= dataId) {
+// 判断是否创建或数据 ID 不一致；（如果正在创建或者当前数据 ID 与新的数据 ID 不一致。）
+            mDiffDataValues.put(DataColumns.ID, dataId);
+// 更新差异数据值；（将新的数据 ID 放入差异数据值的对应键中。）
+        }
+        mDataId = dataId;
+// 更新数据 ID；（将 dataId 赋值给 mDataId。）
+
+        String dataMimeType = js.has(DataColumns.MIME_TYPE)? js.getString(DataColumns.MIME_TYPE)
+                : DataConstants.NOTE;
+// 获取数据 MIME 类型；（如果 JSONObject 中包含指定键，则获取对应的值作为数据 MIME 类型，否则设置为 DataConstants.NOTE。）
+        if (mIsCreate ||!mDataMimeType.equals(dataMimeType)) {
+// 判断是否创建或数据 MIME 类型不一致；（如果正在创建或者当前数据 MIME 类型与新的数据 MIME 类型不一致。）
+            mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
+// 更新差异数据值；（将新的数据 MIME 类型放入差异数据值的对应键中。）
+        }
+        mDataMimeType = dataMimeType;
+// 更新数据 MIME 类型；（将 dataMimeType 赋值给 mDataMimeType。）
+
+        String dataContent = js.has(DataColumns.CONTENT)? js.getString(DataColumns.CONTENT) : "";
+// 获取数据内容；（如果 JSONObject 中包含指定键，则获取对应的值作为数据内容，否则设置为空字符串。）
+        if (mIsCreate ||!mDataContent.equals(dataContent)) {
+// 判断是否创建或数据内容不一致；（如果正在创建或者当前数据内容与新的数据内容不一致。）
+            mDiffDataValues.put(DataColumns.CONTENT, dataContent);
+// 更新差异数据值；（将新的数据内容放入差异数据值的对应键中。）
+        }
+        mDataContent = dataContent;
+// 更新数据内容；（将 dataContent 赋值给 mDataContent。）
+
+        long dataContentData1 = js.has(DataColumns.DATA1)? js.getLong(DataColumns.DATA1) : 0;
+// 获取数据内容数据 1；（如果 JSONObject 中包含指定键，则获取对应的值作为数据内容数据 1，否则设置为 0。）
+        if (mIsCreate || mDataContentData1!= dataContentData1) {
+// 判断是否创建或数据内容数据 1 不一致；（如果正在创建或者当前数据内容数据 1 与新的数据内容数据 1 不一致。）
+            mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
+// 更新差异数据值；（将新的数据内容数据 1 放入差异数据值的对应键中。）
+        }
+        mDataContentData1 = dataContentData1;
+// 更新数据内容数据 1；（将 dataContentData1 赋值给 mDataContentData1。）
+
+        String dataContentData3 = js.has(DataColumns.DATA3)? js.getString(DataColumns.DATA3) : "";
+// 获取数据内容数据 3；（如果 JSONObject 中包含指定键，则获取对应的值作为数据内容数据 3，否则设置为空字符串。）
+        if (mIsCreate ||!mDataContentData3.equals(dataContentData3)) {
+// 判断是否创建或数据内容数据 3 不一致；（如果正在创建或者当前数据内容数据 3 与新的数据内容数据 3 不一致。）
+            mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
+// 更新差异数据值；（将新的数据内容数据 3 放入差异数据值的对应键中。）
+        }
+        mDataContentData3 = dataContentData3;
+// 更新数据内容数据 3；（将 dataContentData3 赋值给 mDataContentData3。）
+    }
+
+    public JSONObject getContent() throws JSONException {
+// 公共方法 getContent；（定义一个公共方法 getContent。）
+        if (mIsCreate) {
+// 判断是否正在创建；（如果正在创建。）
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+// 输出错误日志；（打印错误日志，提示“看起来我们还没有在数据库中创建这个。”）
+            return null;
+// 返回 null；（返回 null。）
+        }
+        JSONObject js = new JSONObject();
+// 创建新的 JSONObject 对象；（创建一个新的 JSONObject 对象。）
+        js.put(DataColumns.ID, mDataId);
+// 设置数据 ID；（将 mDataId 放入 JSONObject 的对应键中。）
+        js.put(DataColumns.MIME_TYPE, mDataMimeType);
+// 设置数据 MIME 类型；（将 mDataMimeType 放入 JSONObject 的对应键中。）
+        js.put(DataColumns.CONTENT, mDataContent);
+// 设置数据内容；（将 mDataContent 放入 JSONObject 的对应键中。）
+        js.put(DataColumns.DATA1, mDataContentData1);
+// 设置数据内容数据 1；（将 mDataContentData1 放入 JSONObject 的对应键中。）
+        js.put(DataColumns.DATA3, mDataContentData3);
+// 设置数据内容数据 3；（将 mDataContentData3 放入 JSONObject 的对应键中。）
+        return js;
+// 返回 JSONObject 对象；（返回创建好的 JSONObject 对象。）
+    }
+
+    public void commit(long noteId, boolean validateVersion, long version) {
+// 公共方法 commit，接收长整型、布尔型和长整型参数；（定义一个公共方法 commit，接收一个长整型 noteId、一个布尔型 validateVersion 和一个长整型 version 参数。）
+
+        if (mIsCreate) {
+// 判断是否正在创建；（如果正在创建。）
+            if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
+// 判断数据 ID 是否无效且差异数据值包含特定键；（如果数据 ID 无效且差异数据值中包含指定键。）
+                mDiffDataValues.remove(DataColumns.ID);
+// 移除该键值对；（从差异数据值中移除该键值对。）
+            }
+
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
+// 设置笔记 ID；（将 noteId 放入差异数据值的对应键中。）
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
+// 插入数据；（向 Notes 的内容数据 URI 中插入差异数据值，获取返回的 URI。）
+            try {
+// 尝试执行以下代码块；（开始 try 代码块。）
+                mDataId = Long.valueOf(uri.getPathSegments().get(1));
+// 获取数据 ID；（从返回的 URI 中获取数据 ID，并赋值给 mDataId。）
+            } catch (NumberFormatException e) {
+// 如果发生数字格式异常，进入此代码块；（捕获 NumberFormatException 异常。）
+                Log.e(TAG, "Get note id error :" + e.toString());
+// 输出错误日志；（打印错误日志，提示“获取笔记 ID 错误：”加上异常信息。）
+                throw new ActionFailureException("create note failed");
+// 抛出异常
+       } else {
+// 如果不是正在创建；（如果不是正在创建的状态。）
+            if (mDiffDataValues.size() > 0) {
+// 如果差异数据值不为空；（如果差异数据值有内容。）
+                int result = 0;
+// 初始化结果变量；（先把结果设为 0。）
+                if (!validateVersion) {
+// 如果不验证版本；（如果不需要验证版本。）
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
+// 更新数据；（用内容解析器更新数据，不考虑版本验证。）
+                } else {
+// 如果要验证版本；（如果需要验证版本。）
+                    result = mContentResolver.update(ContentUris.withAppendedId(
+                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+                            "? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+                                    + " WHERE " + NoteColumns.VERSION + "=?)", new String[]{
+                            String.valueOf(noteId), String.valueOf(version)
+                    });
+// 更新数据并验证版本；（用内容解析器更新数据，同时验证版本。）
+                }
+                if (result == 0) {
+// 如果更新结果为 0；（如果更新没有效果。）
+                    Log.w(TAG, "there is no update. maybe user updates note when syncing");
+// 输出警告日志；（打印警告日志，提示可能是用户在同步时更新了笔记。）
+                }
+            }
+        }
+
+        mDiffDataValues.clear();
+// 清空差异数据值；（把差异数据值清空。）
+        mIsCreate = false;
+// 设置不是创建状态；（设置当前不是创建新数据的状态。）
+
+    public long getId() {
+// 获取 ID 的方法；（定义一个获取数据 ID 的方法。）
+        return mDataId;
+// 返回数据 ID；（返回当前的数据 ID。）
+    }

src/net/micode/notes/gtask/data/SqlNote.java

@@ -0,0 +1,534 @@
+/*
+ * 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.gtask.data;
+// 包声明：net.micode.notes.gtask.data
+import android.appwidget.AppWidgetManager;
+// 导入安卓小部件管理器类
+import android.content.ContentResolver; // 导入内容解析器类
+import android.content.ContentValues; // 导入内容值类
+import android.content.Context; // 导入上下文类
+import android.database.Cursor; // 导入游标类
+import android.net.Uri; // 导入统一资源标识符类
+import android.util.Log; // 导入日志类
+import net.micode.notes.data.Notes; // 导入笔记数据类
+import net.micode.notes.data.Notes.DataColumns; // 导入笔记数据列类
+import net.micode.notes.data.Notes.NoteColumns; // 导入笔记列类
+import net.micode.notes.gtask.exception.ActionFailureException; // 导入操作失败异常类
+import net.micode.notes.tool.GTaskStringUtils; // 导入工具类中的字符串工具类
+import net.micode.notes.tool.ResourceParser; // 导入资源解析器类
+import org.json.JSONArray; // 导入 JSON 数组类
+import org.json.JSONException; // 导入 JSON 异常类
+import org.json.JSONObject; // 导入 JSON 对象类
+import java.util.ArrayList; // 导入 ArrayList 类
+public class SqlNote {
+    // SQL 笔记类定义
+    private static final String TAG = SqlNote.class.getSimpleName();    // 定义静态常量 TAG，为当前类名的简写
+    private static final int INVALID_ID = -99999;    // 定义无效 ID 的常量值
+    public static final String[] PROJECTION_NOTE = new String[]{
+            NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
+            NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
+            NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,
+            NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,
+            NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
+            NoteColumns.VERSION
+    };
+    // 定义笔记投影数组，包含各种列名
+    public static final int ID_COLUMN = 0;    // ID 列的索引常量
+    public static final int ALERTED_DATE_COLUMN = 1;    // 提醒日期列的索引常量
+    public static final int BG_COLOR_ID_COLUMN = 2;    // 背景颜色 ID 列的索引常量
+    public static final int CREATED_DATE_COLUMN = 3;    // 创建日期列的索引常量
+    public static final int HAS_ATTACHMENT_COLUMN = 4;  // 是否有附件列的索引常量
+    public static final int MODIFIED_DATE_COLUMN = 5;    // 修改日期列的索引常量
+    public static final int NOTES_COUNT_COLUMN = 6;    // 笔记数量列的索引常量
+    public static final int PARENT_ID_COLUMN = 7;    // 父 ID 列的索引常量
+    public static final int SNIPPET_COLUMN = 8;    // 摘要列的索引常量
+    public static final int TYPE_COLUMN = 9;    // 类型列的索引常量
+    public static final int WIDGET_ID_COLUMN = 10;    // 小部件 ID 列的索引常量
+    public static final int WIDGET_TYPE_COLUMN = 11;    // 小部件类型列的索引常量
+    public static final int SYNC_ID_COLUMN = 12;    // 同步 ID 列的索引常量
+    public static final int LOCAL_MODIFIED_COLUMN = 13;    // 本地修改列的索引常量
+    public static final int ORIGIN_PARENT_ID_COLUMN = 14;    // 原始父 ID 列的索引常量
+    public static final int GTASK_ID_COLUMN = 15;    // GTask ID 列的索引常量
+    public static final int VERSION_COLUMN = 16;    // 版本列的索引常量
+    private Context mContext;    // 定义上下文变量
+    private ContentResolver mContentResolver;    // 定义内容解析器变量
+    private boolean mIsCreate;   // 定义是否为创建状态的变量
+    private long mId;    // 定义 ID 变量
+    private long mAlertDate;    // 定义提醒日期变量
+    private int mBgColorId;    // 定义背景颜色 ID 变量
+    private long mCreatedDate;    // 定义创建日期变量
+    private int mHasAttachment;    // 定义是否有附件变量
+    private long mModifiedDate;    // 定义修改日期变量
+    private long mParentId;   // 定义父 ID 变量
+    private String mSnippet;    // 定义摘要变量
+    private int mType;    // 定义类型变量
+    private int mWidgetId;    // 定义小部件 ID 变量
+    private int mWidgetType;    // 定义小部件类型变量
+    private long mOriginParent;    // 定义原始父 ID 变量
+    private long mVersion;    // 定义版本变量
+    private ContentValues mDiffNoteValues;
+    // 定义差异笔记值变量
+    private ArrayList<SqlData> mDataList;
+    // 定义 SQL 数据列表变量
+    public SqlNote(Context context) {
+        // 无参构造函数，接受上下文参数
+        mContext = context;
+        // 将传入的上下文赋值给成员变量
+        mContentResolver = context.getContentResolver();
+        // 获取上下文的内容解析器并赋值给成员变量
+        mIsCreate = true;
+        // 设置为创建状态
+        mId = INVALID_ID;
+        // 设置 ID 为无效值
+        mAlertDate = 0;
+        // 设置提醒日期为 0
+        mBgColorId = ResourceParser.getDefaultBgId(context);
+        // 设置背景颜色 ID 为资源解析器获取的默认背景颜色 ID
+        mCreatedDate = System.currentTimeMillis();
+        // 设置创建日期为当前时间戳
+        mHasAttachment = 0;
+        // 设置是否有附件为 0
+        mModifiedDate = System.currentTimeMillis();
+        // 设置修改日期为当前时间戳
+        mParentId = 0;
+        // 设置父 ID 为 0
+        mSnippet = "";
+        // 设置摘要为空字符串
+        mType = Notes.TYPE_NOTE;
+        // 设置类型为笔记类型
+        mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
+        // 设置小部件 ID 为无效值
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+        // 设置小部件类型为无效值
+        mOriginParent = 0;
+        // 设置原始父 ID 为 0
+        mVersion = 0;
+        // 设置版本为 0
+        mDiffNoteValues = new ContentValues();
+        // 创建新的内容值对象并赋值给差异笔记值变量
+        mDataList = new ArrayList<SqlData>();
+        // 创建新的 SQL 数据列表
+    }
+    public SqlNote(Context context, Cursor c) {
+        // 接受上下文和游标参数的构造函数
+        mContext = context; // 将传入的上下文赋值给成员变量
+        mContentResolver = context.getContentResolver(); // 获取上下文的内容解析器并赋值给成员变量
+        mIsCreate = false; // 设置为非创建状态
+        loadFromCursor(c); // 从游标加载数据
+        mDataList = new ArrayList<SqlData>(); // 创建新的 SQL 数据列表
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent(); // 如果类型为笔记类型，加载数据内容
+        mDiffNoteValues = new ContentValues(); // 创建新的内容值对象并赋值给差异笔记值变量
+    }
+    public SqlNote(Context context, long id) {
+        // 接受上下文和 ID 参数的构造函数
+        mContext = context; // 将传入的上下文赋值给成员变量
+        mContentResolver = context.getContentResolver(); // 获取上下文的内容解析器并赋值给成员变量
+        mIsCreate = false;         // 设置为非创建状态
+        loadFromCursor(id);
+        // 从 ID 加载数据
+        mDataList = new ArrayList<SqlData>();
+        // 创建新的 SQL 数据列表
+        if (mType == Notes.TYPE_NOTE)
+            loadDataContent();
+        // 如果类型为笔记类型，加载数据内容
+        mDiffNoteValues = new ContentValues();
+        // 创建新的内容值对象并赋值给差异笔记值变量
+    }
+    private void loadFromCursor(long id) {
+        // 从 ID 加载游标数据的私有方法
+        Cursor c = null;
+        // 初始化游标为 null
+        try {
+            c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
+                    new String[]{
+                            String.valueOf(id)
+                    }, null);
+            // 查询内容解析器，获取指定 ID 的笔记数据游标
+            if (c!= null) {
+                c.moveToNext();
+                loadFromCursor(c);
+                // 如果游标不为 null，移动到下一行并从游标加载数据
+            } else {
+                Log.w(TAG, "loadFromCursor: cursor = null");
+                // 如果游标为 null，记录日志警告
+            }
+        } finally {
+            if (c!= null)
+                c.close();
+            // 最终，如果游标不为 null，关闭游标
+        }
+    }
+    private void loadFromCursor(Cursor c) {
+        // 从游标加载数据的私有方法
+        mId = c.getLong(ID_COLUMN);
+        // 获取游标中 ID 列的值并赋值给成员变量
+        mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
+        // 获取游标中提醒日期列的值并赋值给成员变量
+        mBgColorId = c.getInt(BG_COLOR_ID_COLUMN);
+        // 获取游标中背景颜色 ID 列的值并赋值给成员变量
+        mCreatedDate = c.getLong(CREATED_DATE_COLUMN);
+        // 获取游标中创建日期列的值并赋值给成员变量
+        mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN);
+        // 获取游标中是否有附件列的值并赋值给成员变量
+        mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN);
+        // 获取游标中修改日期列的值并赋值给成员变量
+        mParentId = c.getLong(PARENT_ID_COLUMN);
+        // 获取游标中父 ID 列的值并赋值给成员变量
+        mSnippet = c.getString(SNIPPET_COLUMN);
+        // 获取游标中摘要列的值并赋值给成员变量
+        mType = c.getInt(TYPE_COLUMN);
+        // 获取游标中类型列的值并赋值给成员变量
+        mWidgetId = c.getInt(WIDGET_ID_COLUMN);
+        // 获取游标中小部件 ID 列的值并赋值给成员变量
+        mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
+        // 获取游标中小部件类型列的值并赋值给成员变量
+        mVersion = c.getLong(VERSION_COLUMN);
+        // 获取游标中版本列的值并赋值给成员变量
+    }
+    private void loadDataContent() {
+        // 加载数据内容的私有方法
+        Cursor c = null;
+        // 初始化游标为 null
+        mDataList.clear();
+        // 清空数据列表
+        try {
+            c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
+                    "(note_id=?)", new String[]{
+                            String.valueOf(mId)
+                    }, null);
+            // 查询内容解析器，获取指定笔记 ID 的数据游标
+            if (c!= null) {
+                if (c.getCount() == 0) {
+                    Log.w(TAG, "it seems that the note has not data");
+                    // 如果游标计数为 0，记录日志警告
+                    return;
+                }
+                while (c.moveToNext()) {
+                    SqlData data = new SqlData(mContext, c);
+                    mDataList.add(data);
+                    // 如果游标不为 null，遍历游标并创建 SQL 数据对象添加到数据列表
+                }
+            } else {
+                Log.w(TAG, "loadDataContent: cursor = null");
+                // 如果游标为 null，记录日志警告
+            }
+        } finally {
+            if (c!= null)
+                c.close();     // 最终，如果游标不为 null，关闭游标
+        }
+    }
+    public boolean setContent(JSONObject js) {
+        // 设置内容的方法，接受 JSON 对象参数，返回布尔值
+        try {
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            // 从传入的 JSON 对象中获取名为 GTaskStringUtils.META_HEAD_NOTE 的 JSON 对象
+            if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                Log.w(TAG, "cannot set system folder");
+                // 如果类型为系统文件夹类型，记录日志警告并返回 false
+                return false;
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+                // 如果类型为文件夹类型
+                // for folder we can only update the snnipet and type
+                String snippet = note.has(NoteColumns.SNIPPET)? note
+                       .getString(NoteColumns.SNIPPET) : "";
+                // 获取摘要，如果存在则获取，否则为空字符串
+                if (mIsCreate ||!mSnippet.equals(snippet)) {
+                    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+                }
+                // 如果为创建状态或摘要与当前不同，将摘要添加到差异笔记值中
+                mSnippet = snippet;      // 更新摘要变量
+                int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE)
+                        : Notes.TYPE_NOTE;
+                // 获取类型，如果存在则获取，否则为笔记类型
+                if (mIsCreate || mType!= type) {
+                    mDiffNoteValues.put(NoteColumns.TYPE, type);
+                }
+                // 如果为创建状态或类型与当前不同，将类型添加到差异笔记值中
+                mType = type;
+                // 更新类型变量
+            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+                // 如果类型为笔记类型
+                JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+                // 获取数据数组
+                long id = note.has(NoteColumns.ID)? note.getLong(NoteColumns.ID) : INVALID_ID;
+                // 获取 ID，如果存在则获取，否则为无效值
+                if (mIsCreate || mId!= id) {
+                    mDiffNoteValues.put(NoteColumns.ID, id);
+                }
+                // 如果为创建状态或 ID 与当前不同，将 ID 添加到差异笔记值中
+                mId = id;                // 更新 ID 变量
+                long alertDate = note.has(NoteColumns.ALERTED_DATE)? note
+                       .getLong(NoteColumns.ALERTED_DATE) : 0;  // 获取提醒日期，如果存在则获取，否则为 0
+                if (mIsCreate || mAlertDate!= alertDate) {
+                    mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
+                }
+                // 如果为创建状态或提醒日期与当前不同，将提醒日期添加到差异笔记值中
+                mAlertDate = alertDate;     // 更新提醒日期变量
+                int bgColorId = note.has(NoteColumns.BG_COLOR_ID)? note
+                       .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
+                // 获取背景颜色 ID，如果存在则获取，否则为默认背景颜色 ID
+                if (mIsCreate || mBgColorId!= bgColorId) {
+                    mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
+                }
+                // 如果为创建状态或背景颜色 ID 与当前不同，将背景颜色 ID 添加到差异笔记值中
+                mBgColorId = bgColorId;   // 更新背景颜色 ID 变量
+                long createDate = note.has(NoteColumns.CREATED_DATE)? note
+                       .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
+                // 获取创建日期，如果存在则获取，否则为当前时间戳
+                if (mIsCreate || mCreatedDate!= createDate) {
+                    mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
+                }
+                // 如果为创建状态或创建日期与当前不同，将创建日期添加到差异笔记值中
+                mCreatedDate = createDate;
+                // 更新创建日期变量
+int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT)? note
+       .getInt(NoteColumns.HAS_ATTACHMENT) : 0;
+// 判断 JSON 对象 note 中是否存在 HAS_ATTACHMENT 字段，如果有则获取其整数值，否则将 hasAttachment 初始化为 0。
+if (mIsCreate || mHasAttachment!= hasAttachment) {
+    mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
+}
+// 如果当前处于创建状态或者当前的 hasAttachment 值与新获取的值不同，则将新的 hasAttachment 值放入差异笔记值的 HAS_ATTACHMENT 字段中。
+mHasAttachment = hasAttachment;
+// 更新当前对象的 hasAttachment 变量。
+long modifiedDate = note.has(NoteColumns.MODIFIED_DATE)? note
+       .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
+// 判断 JSON 对象 note 中是否存在 MODIFIED_DATE 字段，如果有则获取其长整数值，否则将 modifiedDate 初始化为当前时间戳。
+if (mIsCreate || mModifiedDate!= modifiedDate) {
+    mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
+}
+// 如果当前处于创建状态或者当前的 modifiedDate 值与新获取的值不同，则将新的 modifiedDate 值放入差异笔记值的 MODIFIED_DATE 字段中。
+mModifiedDate = modifiedDate;
+// 更新当前对象的 modifiedDate 变量。
+long parentId = note.has(NoteColumns.PARENT_ID)? note
+       .getLong(NoteColumns.PARENT_ID) : 0;
+// 判断 JSON 对象 note 中是否存在 PARENT_ID 字段，如果有则获取其长整数值，否则将 parentId 初始化为 0。
+if (mIsCreate || mParentId!= parentId) {
+    mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
+}
+// 如果当前处于创建状态或者当前的 parentId 值与新获取的值不同，则将新的 parentId 值放入差异笔记值的 PARENT_ID 字段中。
+mParentId = parentId;
+// 更新当前对象的 parentId 变量。
+String snippet = note.has(NoteColumns.SNIPPET)? note
+       .getString(NoteColumns.SNIPPET) : "";
+// 判断 JSON 对象 note 中是否存在 SNIPPET 字段，如果有则获取其字符串值，否则将 snippet 初始化为空字符串。
+
+if (mIsCreate ||!mSnippet.equals(snippet)) {
+    mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
+}
+// 如果当前处于创建状态或者当前的 snippet 值与新获取的值不同，则将新的 snippet 值放入差异笔记值的 SNIPPET 字段中
+mSnippet = snippet;
+// 更新当前对象的 snippet 变量。
+int type = note.has(NoteColumns.TYPE)? note.getInt(NoteColumns.TYPE)
+        : Notes.TYPE_NOTE;
+// 判断 JSON 对象 note 中是否存在 TYPE 字段，如果有则获取其整数值，否则将 type 初始化为笔记类型。
+if (mIsCreate || mType!= type) {
+    mDiffNoteValues.put(NoteColumns.TYPE, type);
+}
+// 如果当前处于创建状态或者当前的 type 值与新获取的值不同，则将新的 type 值放入差异笔记值的 TYPE 字段中。
+mType = type; // 更新当前对象的 type 变量。
+int widgetId = note.has(NoteColumns.WIDGET_ID)? note.getInt(NoteColumns.WIDGET_ID)
+        : AppWidgetManager.INVALID_APPWIDGET_ID;
+// 判断 JSON 对象 note 中是否存在 WIDGET_ID 字段，如果有则获取其整数值，否则将 widgetId 初始化为无效小部件 ID。
+if (mIsCreate || mWidgetId!= widgetId) {
+    mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
+}
+// 如果当前处于创建状态或者当前的 widgetId 值与新获取的值不同，则将新的 widgetId 值放入差异笔记值的 WIDGET_ID 字段中。
+mWidgetId = widgetId;
+// 更新当前对象的 widgetId 变量。
+int widgetType = note.has(NoteColumns.WIDGET_TYPE)? note
+       .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
+// 判断 JSON 对象 note 中是否存在 WIDGET_TYPE 字段，如果有则获取其整数值，否则将 widgetType 初始化为无效小部件类型。
+if (mIsCreate || mWidgetType!= widgetType) {
+    mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
+}
+// 如果当前处于创建状态或者当前的 widgetType 值与新获取的值不同，则将新的 widgetType 值放入差异笔记值的 WIDGET_TYPE 字段中。
+mWidgetType = widgetType; // 更新当前对象的 widgetType 变量。
+long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID)? note
+       .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; // 判断 JSON 对象 note 中是否存在 ORIGIN_PARENT_ID 字段，如果有则获取其长整数值，否则将 originParent 初始化为 0。
+if (mIsCreate || mOriginParent!= originParent) {
+    mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
+}
+// 如果当前处于创建状态或者当前的 originParent 值与新获取的值不同，则将新的 originParent 值放入差异笔记值的 ORIGIN_PARENT_ID 字段中。
+mOriginParent = originParent;
+// 更新当前对象的 originParent 变量。
+for (int i = 0; i < dataArray.length(); i++) {
+    JSONObject data = dataArray.getJSONObject(i);    // 从 JSON 数组 dataArray 中获取第 i 个元素，即一个 JSON 对象，并赋值给 data。
+    SqlData sqlData = null;   // 初始化一个 SqlData 对象为 null。
+    if (data.has(DataColumns.ID)) {
+        long dataId = data.getLong(DataColumns.ID);   // 如果 data 中包含 ID 字段，则获取其长整数值并赋值给 dataId。
+        for (SqlData temp : mDataList) {
+            if (dataId == temp.getId()) {
+                sqlData = temp;
+            }
+        }
+        // 在当前对象的 mDataList 中遍历每个 SqlData 对象 temp，如果 dataId 与 temp 的 ID 相等，则将 temp 赋值给 sqlData。
+    }
+    if (sqlData == null) {
+        sqlData = new SqlData(mContext);
+        mDataList.add(sqlData);
+    }
+    // 如果 sqlData 为 null，即没有找到匹配的 SqlData 对象，则创建一个新的 SqlData 对象并添加到 mDataList 中。
+
+    sqlData.setContent(data);
+    // 调用 sqlData 的 setContent 方法，将当前的 data 对象作为参数传入。
+}
+public JSONObject getContent() {
+    try {
+        JSONObject js = new JSONObject();
+        // 创建一个新的 JSON 对象 js。
+        if (mIsCreate) {
+            Log.e(TAG, "it seems that we haven't created this in database yet");
+            return null;
+        }
+        // 如果当前处于创建状态，则记录日志并返回 null。
+        JSONObject note = new JSONObject();
+        // 创建一个新的 JSON 对象 note。
+        if (mType == Notes.TYPE_NOTE) {
+            note.put(NoteColumns.ID, mId);
+            note.put(NoteColumns.ALERTED_DATE, mAlertDate);
+            note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
+            note.put(NoteColumns.CREATED_DATE, mCreatedDate);
+            note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment);
+            note.put(NoteColumns.MODIFIED_DATE, mModifiedDate);
+            note.put(NoteColumns.PARENT_ID, mParentId);
+            note.put(NoteColumns.SNIPPET, mSnippet);
+            note.put(NoteColumns.TYPE, mType);
+            note.put(NoteColumns.WIDGET_ID, mWidgetId);
+            note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
+            note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
+            js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+            // 如果当前对象的类型是笔记类型，则将各种属性放入 note 中，并将 note 放入 js 的特定键下。
+
+            JSONArray dataArray = new JSONArray();
+            for (SqlData sqlData : mDataList) {
+                JSONObject data = sqlData.getContent();
+                if (data!= null) {
+                    dataArray.put(data);
+                }
+            }
+            js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+            // 创建一个新的 JSON 数组 dataArray，遍历数据列表获取每个 SqlData 的内容放入 JSON 数组中，再将 dataArray 放入 js 的特定键下。
+        } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
+            note.put(NoteColumns.ID, mId);
+            note.put(NoteColumns.TYPE, mType);
+            note.put(NoteColumns.SNIPPET, mSnippet);
+            js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+        }
+        // 如果当前对象的类型是文件夹类型或系统类型，则只将 ID、类型和摘要放入 note 中，再将 note 放入 js 的特定键下。
+        return js;
+    } catch (JSONException e) {
+        Log.e(TAG, e.toString());
+        e.printStackTrace();
+    }
+    return null;
+}
+public void setParentId(long id) {
+    mParentId = id; // 更新当前对象的父 ID 变量。
+    mDiffNoteValues.put(NoteColumns.PARENT_ID, id); // 将新的父 ID 放入差异笔记值的 PARENT_ID 字段中。
+}
+public void setGtaskId(String gid) {
+    mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);  // 将新的 GTask ID 放入差异笔记值的 GTASK_ID 字段中。
+}
+public void setSyncId(long syncId) {
+    mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);  // 将新的同步 ID 放入差异笔记值的 SYNC_ID 字段中。
+}
+public void resetLocalModified() {
+    mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);     // 将本地修改状态设置为 0，并放入差异笔记值的 LOCAL_MODIFIED 字段中
+}
+public long getId() {
+    return mId; // 返回当前对象的 ID。
+}
+public long getParentId() {
+    return mParentId; // 返回当前对象的父 ID
+}
+public String getSnippet() {
+    return mSnippet;    // 返回当前对象的摘要
+}
+public boolean isNoteType() {
+    return mType == Notes.TYPE_NOTE;
+    // 判断是否是笔记类型的方法。如果当前对象的类型等于笔记类型，则返回 true，否则返回 false。
+}
+
+public void commit(boolean validateVersion) {
+    if (mIsCreate) {
+        if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
+            mDiffNoteValues.remove(NoteColumns.ID);
+        }
+        // 如果当前处于创建状态且 ID 为无效值且差异笔记值中包含 ID 字段，则移除该 ID 字段。
+
+        Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
+        try {
+            mId = Long.valueOf(uri.getPathSegments().get(1));
+        } catch (NumberFormatException e) {
+            Log.e(TAG, "Get note id error :" + e.toString());
+            throw new ActionFailureException("create note failed");
+        }
+        // 插入新的笔记数据到内容解析器中，并获取新插入的笔记 ID。如果插入失败则抛出异常。
+
+        if (mId == 0) {
+            throw new IllegalStateException("Create thread id failed");
+        }
+        // 如果当前 ID 为 0，则抛出非法状态异常。
+
+        if (mType == Notes.TYPE_NOTE) {
+            for (SqlData sqlData : mDataList) {
+                sqlData.commit(mId, false, -1);
+            }
+        }
+        // 如果类型是笔记类型，则对数据列表中的每个 SqlData 对象调用提交方法。
+    } else {
+        if (mId <= 0 && mId!= Notes.ID_ROOT_FOLDER && mId!= Notes.ID_CALL_RECORD_FOLDER) {
+            Log.e(TAG, "No such note");
+            throw new IllegalStateException("Try to update note with invalid id");
+        }
+        // 如果不是创建状态且 ID 无效（不等于根文件夹 ID 和通话记录文件夹 ID），则抛出异常。
+
+        if (mDiffNoteValues.size() > 0) {
+            mVersion++;
+            int result = 0;
+            if (!validateVersion) {
+                result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                        + NoteColumns.ID + "=?)", new String[]{
+                        String.valueOf(mId)
+                });
+            } else {
+                result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+                        + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+                        new String[]{
+                                String.valueOf(mId), String.valueOf(mVersion)
+                        });
+            }
+            if (result == 0) {
+                Log.w(TAG, "there is no update. maybe user updates note when syncing");
+            }
+        }
+        // 如果差异笔记值不为空，则更新版本号，并根据 validateVersion 的值选择不同的更新方式。如果更新结果为 0，则记录日志警告。
+
+        if (mType == Notes.TYPE_NOTE) {
+            for (SqlData sqlData : mDataList) {
+                sqlData.commit(mId, validateVersion, mVersion);
+            }
+        }
+        // 如果类型是笔记类型，则对数据列表中的每个 SqlData 对象调用提交方法。
+    }
+    // refresh local info
+    loadFromCursor(mId);
+    if (mType == Notes.TYPE_NOTE)
+        loadDataContent();      // 刷新本地信息，根据 ID 重新加载当前对象的数据，如果类型是笔记类型，则加载数据内容。
+    mDiffNoteValues.clear();
+    mIsCreate = false;   // 清空差异笔记值，并设置为非创建状态。
+}

src/net/micode/notes/gtask/data/Task.java

@@ -0,0 +1,397 @@
+// 版权声明，表明此代码受Apache License 2.0许可，版权归The MiCode Open Source Community（2010 - 2011）所有
+/*
+ * 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.
+ */
+// 包声明，此Task类位于net.micode.notes.gtask.data包下
+package net.micode.notes.gtask.data;
+// 导入相关类
+import android.database.Cursor;
+import android.text.TextUtils;
+import android.util.Log;
+import net.micode.notes.data.Notes;
+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.gtask.exception.ActionFailureException;
+import net.micode.notes.tool.GTaskStringUtils;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+// Task类继承自Node类（此处Node类的定义未给出）
+public class Task extends Node {
+    // 定义一个私有静态常量TAG，其值为Task类的简单名称，用于日志记录
+    private static final String TAG = Task.class.getSimpleName();
+    // 表示任务是否完成的布尔值，初始化为false
+    private boolean mCompleted;
+    // 存储任务备注信息的字符串，初始化为null
+    private String mNotes;
+    // 存储任务元数据信息的JSONObject，初始化为null
+    private JSONObject mMetaInfo;
+    // 指向任务前一个兄弟任务的引用，初始化为null
+    private Task mPriorSibling;
+    // 指向任务所在任务列表的引用，初始化为null
+    private TaskList mParent;
+    // Task类的构造函数，调用父类（Node）的构造函数，并初始化成员变量
+    public Task() {
+        super();
+        mCompleted = false;
+        mNotes = null;
+        mPriorSibling = null;
+        mParent = null;
+        mMetaInfo = null;
+    }
+    // 生成创建任务动作的JSONObject的方法
+    public JSONObject getCreateAction(int actionId) {
+        // 创建一个新的JSONObject实例
+        JSONObject js = new JSONObject();
+        try {
+            // 在JSON对象中设置"action_type"键值对，值为创建任务类型（通过GTaskStringUtils类中的常量）
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+            // 在JSON对象中设置"action_id"键值对，值为传入的actionId参数
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+            // 在JSON对象中设置"index"键值对，值为通过父任务列表获取的此任务的索引
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
+            // 创建一个名为"entity_delta"的新JSONObject实例，用于存储任务实体的变化信息
+            JSONObject entity = new JSONObject();
+            // 在"entity_delta"对象中设置"name"键值对，值为任务名称（通过getName()方法获取）
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            // 在"entity_delta"对象中设置"creator_id"键值对，值为"null"
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            // 在"entity_delta"对象中设置"entity_type"键值对，值为任务类型（通过GTaskStringUtils类中的常量）
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_TASK);
+            // 如果任务备注信息不为null，在"entity_delta"对象中设置"notes"键值对，值为任务备注（通过getNotes()方法获取）
+            if (getNotes()!= null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+            }
+            // 在主JSON对象（js）中设置"entity_delta"键值对，值为刚才创建的"entity"对象
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+            // 在JSON对象中设置"parent_id"键值对，值为父任务的ID（通过父任务的getGid()方法获取）
+            js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
+            // 在JSON对象中设置"dest_parent_type"键值对，值为目标父实体类型（通过GTaskStringUtils类中的常量，这里是组类型）
+            js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+            // 在JSON对象中设置"list_id"键值对，值为父任务的ID（与"parent_id"相同）
+            js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
+            // 如果前一个兄弟任务不为null，在JSON对象中设置"prior_sibling_id"键值对，值为前一个兄弟任务的ID（通过前一个兄弟任务的getGid()方法获取）
+            if (mPriorSibling!= null) {
+                js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
+            }
+        } catch (JSONException e) {
+            // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+            // 抛出ActionFailureException异常，表示生成创建任务的JSON对象失败
+            throw new ActionFailureException("fail to generate task - create jsonobject");
+        }
+        return js;
+    }
+    // 生成更新任务动作的JSONObject的方法
+    public JSONObject getUpdateAction(int actionId) {
+        // 创建一个新的JSONObject实例
+        JSONObject js = new JSONObject();
+        try {
+            // 在JSON对象中设置"action_type"键值对，值为更新任务类型（通过GTaskStringUtils类中的常量）
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+            // 在JSON对象中设置"action_id"键值对，值为传入的actionId参数
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+            // 在JSON对象中设置"id"键值对，值为任务的ID（通过getGid()方法获取）
+            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+            // 创建一个名为"entity_delta"的新JSONObject实例，用于存储任务实体的变化信息
+            JSONObject entity = new JSONObject();
+            // 在"entity_delta"对象中设置"name"键值对，值为任务名称（通过getName()方法获取）
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            // 如果任务备注信息不为null，在"entity_delta"对象中设置"notes"键值对，值为任务备注（通过getNotes()方法获取）
+            if (getNotes()!= null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+            }
+            // 在"entity_delta"对象中设置"deleted"键值对，值为任务的删除标记（通过getDeleted()方法获取，此处未给出getDeleted()方法的实现）
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            // 在主JSON对象（js）中设置"entity_delta"键值对，值为刚才创建的"entity"对象
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+        } catch (JSONException e) {
+            // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+            // 抛出ActionFailureException异常，表示生成更新任务的JSON对象失败
+            throw new ActionFailureException("fail to generate task - update jsonobject");
+        }
+        return js;
+    }
+    // 根据远程的JSONObject设置任务内容的方法
+    public void setContentByRemoteJSON(JSONObject js) {
+        // 如果传入的JSON对象不为null
+        if (js!= null) {
+            try {
+                // 如果JSON对象包含特定的"id"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+                    // 设置任务的ID（通过setGid()方法，此处未给出setGid()方法的实现，参数为从JSON对象中获取的字符串值）
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+                }
+                // 如果JSON对象包含特定的"last_modified"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+                    // 设置任务的最后修改时间（通过setLastModified()方法，此处未给出setLastModified()方法的实现，参数为从JSON对象中获取的长整型值）
+                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+                }
+                // 如果JSON对象包含特定的"name"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+                    // 设置任务的名称（通过setName()方法，此处未给出setName()方法的实现，参数为从JSON对象中获取的字符串值）
+                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
+                }
+                // 如果JSON对象包含特定的"notes"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
+                    // 设置任务的备注信息（通过setNotes()方法，参数为从JSON对象中获取的字符串值）
+                    setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
+                }
+                // 如果JSON对象包含特定的"deleted"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
+                    // 设置任务的删除标记（通过setDeleted()方法，此处未给出setDeleted()方法的实现，参数为从JSON对象中获取的布尔值）
+                    setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
+                }
+                // 如果JSON对象包含特定的"completed"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
+                    // 设置任务的完成状态（通过setCompleted()方法，参数为从JSON对象中获取的布尔值）
+                    setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
+                }
+            } catch (JSONException e) {
+                // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+                Log.e(TAG, e.toString());
+                // 打印异常堆栈信息
+                e.printStackTrace();
+                // 抛出ActionFailureException异常，表示从JSON对象获取任务内容失败
+                throw new ActionFailureException("fail to get task content from jsonobject");
+            }
+        }
+    }
+    // 根据本地的JSONObject设置任务内容的方法
+    public void setContentByLocalJSON(JSONObject js) {
+        // 如果传入的JSON对象为null或者不包含特定的头信息（通过GTaskStringUtils类中的常量）
+        if (js == null ||!js.has(GTaskStringUtils.META_HEAD_NOTE)
+                ||!js.has(GTaskStringUtils.META_HEAD_DATA)) {
+            // 记录警告日志（使用Log.w，标签为TAG，内容为指定的字符串）
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+        }
+        try {
+            // 从JSON对象中获取名为"note"的JSONObject（通过GTaskStringUtils类中的常量）
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            // 从JSON对象中获取名为"dataArray"的JSONArray（通过GTaskStringUtils类中的常量）
+            JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+            // 如果"note"对象中的"type"键对应的值不等于Notes.TYPE_NOTE（此处Notes类和TYPE_NOTE的定义未给出）
+            if (note.getInt(NoteColumns.TYPE)!= Notes.TYPE_NOTE) {
+                // 记录错误日志（使用Log.e，标签为TAG，内容为指定的字符串）
+                Log.e(TAG, "invalid type");
+                return;
+            }
+            // 遍历"dataArray"
+            for (int i = 0; i < dataArray.length(); i++) {
+                // 获取"dataArray"中的每个JSONObject元素
+                JSONObject data = dataArray.getJSONObject(i);
+                // 如果"data"对象中的"mime_type"键（通过DataColumns类中的常量）对应的值等于特定的笔记类型（通过DataConstants类中的常量）
+                if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+                    // 设置任务的名称（通过setName()方法，参数为"data"对象中"content"键对应的值）
+                    setName(data.getString(DataColumns.CONTENT));
+                    break;
+                }
+            }
+
+        } catch (JSONException e) {
+            // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+        }
+    }
+    // 从任务内容生成本地JSONObject的方法
+    public JSONObject getLocalJSONFromContent() {
+        // 获取任务名称
+        String name = getName();
+        try {
+            // 如果元数据信息（mMetaInfo）为null，表示是从网页创建的新任务
+            if (mMetaInfo == null) {
+                // 如果任务名称为null
+                if (name == null) {
+                    // 记录警告日志（使用Log.w，标签为TAG，内容为指定的字符串）
+                    Log.w(TAG, "the note seems to be an empty one");
+                    return null;
+                }
+                // 创建一个新的JSONObject实例
+                JSONObject js = new JSONObject();
+                // 创建一个名为"note"的新JSONObject实例
+                JSONObject note = new JSONObject();
+                // 创建一个新的JSONArray实例
+                JSONArray dataArray = new JSONArray();
+                // 创建一个名为"data"的新JSONObject实例
+                JSONObject data = new JSONObject();
+                // 在"data"对象中设置"content"键值对，值为任务名称
+                data.put(DataColumns.CONTENT, name);
+                // 将"data"对象添加到"dataArray"中
+                dataArray.put(data);
+                // 在主JSON对象（js）中设置"dataArray"键值对，值为刚才创建的"dataArray"对象
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+                // 在"note"对象中设置"type"键值对，值为Notes.TYPE_NOTE（此处Notes类和TYPE_NOTE的定义未给出）
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                // 在主JSON对象（js）中设置"note"键值对，值为刚才创建的"note"对象
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+                return js;
+            } else {
+                // 如果元数据信息不为null，表示是已同步的任务
+                // 从元数据信息中获取名为"note"的JSONObject（通过GTaskStringUtils类中的常量）
+                JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+                // 从元数据信息中获取名为"dataArray"的JSONArray（通过GTaskStringUtils类中的常量）
+                JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+                // 遍历"dataArray"
+                for (int i = 0; i < dataArray.length(); i++) {
+                    // 获取"dataArray"中的每个JSONObject元素
+                    JSONObject data = dataArray.getJSONObject(i);
+                    // 如果"data"对象中的"mime_type"键（通过DataColumns类中的常量）对应的值等于特定的笔记类型（通过DataConstants类中的常量）
+                    if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+                        // 在"data"对象中设置"content"键值对，值为当前任务名称
+                        data.put(DataColumns.CONTENT, getName());
+                        break;
+                    }
+                }
+                // 在"note"对象中设置"type"键值对，值为Notes.TYPE_NOTE（此处Notes类和TYPE_NOTE的定义未给出）
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                return mMetaInfo;
+            }
+        } catch (JSONException e) {
+            // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+            return null;
+        }
+    }
+    // 设置任务元数据信息的方法
+ // 设置任务元数据信息的方法。参数metaData是一个包含元数据的对象
+public void setMetaInfo(MetaData metaData) {
+    // 如果传入的metaData不为null并且metaData的getNotes()方法返回值也不为null
+    if (metaData!= null && metaData.getNotes()!= null) {
+        try {
+            // 将metaData中的备注信息（通过getNotes()获取）转换为JSONObject，并赋值给mMetaInfo
+            mMetaInfo = new JSONObject(metaData.getNotes());
+        } catch (JSONException e) {
+            // 如果在转换过程中出现JSONException，记录一个警告日志（包含异常信息）
+            Log.w(TAG, e.toString());
+            // 将mMetaInfo设置为null
+            mMetaInfo = null;
+        }
+    }
+}
+// 根据数据库游标确定同步操作类型的方法。参数c是一个数据库游标对象
+public int getSyncAction(Cursor c) {
+    try {
+        // 用于存储从元数据中获取的笔记信息的JSONObject，初始化为null
+        JSONObject noteInfo = null;
+        // 如果mMetaInfo不为null并且包含特定的"note"头信息（通过GTaskStringUtils类中的常量）
+        if (mMetaInfo!= null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
+            // 从mMetaInfo中获取名为"note"的JSONObject
+            noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+        }
+        // 如果noteInfo为null，表示笔记元数据似乎已被删除
+        if (noteInfo == null) {
+            Log.w(TAG, "it seems that note meta has been deleted");
+            // 返回更新远程操作类型（SYNC_ACTION_UPDATE_REMOTE的值未给出，应该是一个预定义的表示更新远程操作的常量）
+            return SYNC_ACTION_UPDATE_REMOTE;
+        }
+        // 如果noteInfo不包含特定的"id"键（通过NoteColumns类中的常量）
+        if (!noteInfo.has(NoteColumns.ID)) {
+            Log.w(TAG, "remote note id seems to be deleted");
+            // 返回更新本地操作类型（SYNC_ACTION_UPDATE_LOCAL的值未给出，应该是一个预定义的表示更新本地操作的常量）
+            return SYNC_ACTION_UPDATE_LOCAL;
+        }
+        // 验证数据库中的笔记ID是否与从noteInfo中获取的笔记ID匹配
+        if (c.getLong(SqlNote.ID_COLUMN)!= noteInfo.getLong(NoteColumns.ID)) {
+            Log.w(TAG, "note id doesn't match");
+            // 如果不匹配，返回更新本地操作类型
+            return SYNC_ACTION_UPDATE_LOCAL;
+        }
+        // 如果本地没有更新（通过检查数据库游标中的本地修改标志列，值为0表示无本地修改）
+        if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
+            // 如果数据库中的同步ID与任务的最后修改时间匹配
+            if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                // 两边都无更新，返回无操作类型（SYNC_ACTION_NONE的值未给出，应该是一个预定义的表示无操作的常量）
+                return SYNC_ACTION_NONE;
+            } else {
+                // 将远程数据应用到本地，返回更新本地操作类型
+                return SYNC_ACTION_UPDATE_LOCAL;
+            }
+        } else {
+            // 验证gtask id是否匹配，即数据库游标中的gtask id与任务的ID（通过getGid()方法获取）是否相等
+            if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
+                Log.e(TAG, "gtask id doesn't match");
+                // 如果不匹配，返回错误操作类型（SYNC_ACTION_ERROR的值未给出，应该是一个预定义的表示错误操作的常量）
+                return SYNC_ACTION_ERROR;
+            }
+            // 如果数据库中的同步ID与任务的最后修改时间匹配
+            if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                // 仅有本地修改，返回更新远程操作类型
+                return SYNC_ACTION_UPDATE_REMOTE;
+            } else {
+                // 返回更新冲突操作类型（SYNC_ACTION_UPDATE_CONFLICT的值未给出，应该是一个预定义的表示更新冲突的常量）
+                return SYNC_ACTION_UPDATE_CONFLICT;
+            }
+        }
+    } catch (Exception e) {
+        // 如果发生任何异常，记录错误日志（包含异常信息）
+        Log.e(TAG, e.toString());
+        // 打印异常堆栈信息
+        e.printStackTrace();
+    }
+    // 如果在方法执行过程中出现错误，返回错误操作类型
+    return SYNC_ACTION_ERROR;
+}
+// 判断任务是否值得保存的方法
+public boolean isWorthSaving() {
+    // 如果mMetaInfo不为null，或者任务名称不为null且去除空格后的长度大于0，或者备注信息不为null且去除空格后的长度大于0，则任务值得保存，返回true
+    return mMetaInfo!= null || (getName()!= null && getName().trim().length() > 0)
+            || (getNotes()!= null && getNotes().trim().length() > 0);
+}
+// 设置任务完成状态的方法。参数completed是表示完成状态的布尔值
+public void setCompleted(boolean completed) {
+    this.mCompleted = completed;
+}
+// 设置任务备注信息的方法。参数notes是包含备注信息的字符串
+public void setNotes(String notes) {
+    this.mNotes = notes;
+}
+// 设置任务前一个兄弟任务的方法。参数priorSibling是指向前一个兄弟任务的Task对象引用
+public void setPriorSibling(Task priorSibling) {
+    this.mPriorSibling = priorSibling;
+}
+// 设置任务所在任务列表的方法。参数parent是指向任务列表的TaskList对象引用
+public void setParent(TaskList parent) {
+    this.mParent = parent;
+}
+// 获取任务完成状态的方法，返回任务的完成状态（布尔值）
+public boolean getCompleted() {
+    return this.mCompleted;
+}
+// 获取任务备注信息的方法，返回任务的备注信息（字符串）
+public String getNotes() {
+    return this.mNotes;
+}
+// 获取任务前一个兄弟任务的方法，返回指向前一个兄弟任务的Task对象引用
+public Task getPriorSibling() {
+    return this.mPriorSibling;
+}
+// 获取任务所在任务列表的方法，返回指向任务列表的TaskList对象引用
+public TaskList getParent() {
+    return this.mParent;
+}

src/net/micode/notes/gtask/data/TaskList.java

@@ -0,0 +1,400 @@
+// 版权声明，此代码受Apache License 2.0许可，版权归The MiCode Open Source Community（2010 - 2011）所有
+/*
+ * 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.
+ */
+// 包声明，此TaskList类位于net.micode.notes.gtask.data包下
+package net.micode.notes.gtask.data;
+// 导入相关类
+import android.database.Cursor;
+import android.util.Log;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.tool.GTaskStringUtils;
+import org.json.JSONException;
+import org.json.JSONObject;
+import java.util.ArrayList;
+// TaskList类继承自Node类（此处Node类的定义未给出）
+public class TaskList extends Node {
+    // 定义一个私有静态常量TAG，其值为TaskList类的简单名称，用于日志记录
+    private static final String TAG = TaskList.class.getSimpleName();
+    // 存储任务列表索引的整数，初始值为1
+    private int mIndex;
+    // 存储任务列表中Task对象的ArrayList
+    private ArrayList<Task> mChildren;
+    // TaskList类的构造函数，调用父类（Node）的构造函数，并初始化mChildren和mIndex
+    public TaskList() {
+        super();
+        mChildren = new ArrayList<Task>();
+        mIndex = 1;
+    }
+    // 生成创建任务列表动作的JSONObject的方法
+    public JSONObject getCreateAction(int actionId) {
+        // 创建一个新的JSONObject实例
+        JSONObject js = new JSONObject();
+        try {
+            // 在JSON对象中设置"action_type"键值对，值为创建任务列表类型（通过GTaskStringUtils类中的常量）
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+            // 在JSON对象中设置"action_id"键值对，值为传入的actionId参数
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+            // 在JSON对象中设置"index"键值对，值为任务列表的索引（mIndex）
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
+            // 创建一个名为"entity_delta"的新JSONObject实例，用于存储任务列表实体的变化信息
+            JSONObject entity = new JSONObject();
+            // 在"entity_delta"对象中设置"name"键值对，值为任务列表名称（通过getName()方法获取）
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            // 在"entity_delta"对象中设置"creator_id"键值对，值为"null"
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            // 在"entity_delta"对象中设置"entity_type"键值对，值为任务列表类型（通过GTaskStringUtils类中的常量）
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+            // 在主JSON对象（js）中设置"entity_delta"键值对，值为刚才创建的"entity"对象
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+        } catch (JSONException e) {
+            // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+            // 抛出ActionFailureException异常，表示生成创建任务列表的JSON对象失败
+            throw new ActionFailureException("fail to generate tasklist - create jsonobject");
+        }
+        return js;
+    }
+    // 生成更新任务列表动作的JSONObject的方法
+    public JSONObject getUpdateAction(int actionId) {
+        // 创建一个新的JSONObject实例
+        JSONObject js = new JSONObject();
+        try {
+            // 在JSON对象中设置"action_type"键值对，值为更新任务列表类型（通过GTaskStringUtils类中的常量）
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+            // 在JSON对象中设置"action_id"键值对，值为传入的actionId参数
+            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+            // 在JSON对象中设置"id"键值对，值为任务列表的ID（通过getGid()方法获取）
+            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+            // 创建一个名为"entity_delta"的新JSONObject实例，用于存储任务列表实体的变化信息
+            JSONObject entity = new JSONObject();
+            // 在"entity_delta"对象中设置"name"键值对，值为任务列表名称（通过getName()方法获取）
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            // 在"entity_delta"对象中设置"deleted"键值对，值为任务列表的删除标记（通过getDeleted()方法获取，此处未给出getDeleted()方法的实现）
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            // 在主JSON对象（js）中设置"entity_delta"键值对，值为刚才创建的"entity"对象
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+        } catch (JSONException e) {
+            // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+            // 抛出ActionFailureException异常，表示生成更新任务列表的JSON对象失败
+            throw new ActionFailureException("fail to generate tasklist - update jsonobject");
+        }
+        return js;
+    }
+    // 根据远程的JSONObject设置任务列表内容的方法
+    public void setContentByRemoteJSON(JSONObject js) {
+        // 如果传入的JSON对象不为null
+        if (js!= null) {
+            try {
+                // 如果JSON对象包含特定的"id"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+                    // 设置任务列表的ID（通过setGid()方法，此处未给出setGid()方法的实现，参数为从JSON对象中获取的字符串值）
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+                }
+                // 如果JSON对象包含特定的"last_modified"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+                    // 设置任务列表的最后修改时间（通过setLastModified()方法，此处未给出setLastModified()方法的实现，参数为从JSON对象中获取的长整型值）
+                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+                }
+                // 如果JSON对象包含特定的"name"键（通过GTaskStringUtils类中的常量）
+                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+                    // 设置任务列表的名称（通过setName()方法，此处未给出setName()方法的实现，参数为从JSON对象中获取的字符串值）
+                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
+                }
+            } catch (JSONException e) {
+                // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+                Log.e(TAG, e.toString());
+                // 打印异常堆栈信息
+                e.printStackTrace();
+                // 抛出ActionFailureException异常，表示从JSON对象获取任务列表内容失败
+                throw new ActionFailureException("fail to get tasklist content from jsonobject");
+            }
+        }
+    }
+    // 根据本地的JSONObject设置任务列表内容的方法
+    public void setContentByLocalJSON(JSONObject js) {
+        // 如果传入的JSON对象为null或者不包含特定的头信息（通过GTaskStringUtils类中的常量）
+        if (js == null ||!js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+            // 记录警告日志（使用Log.w，标签为TAG，内容为指定的字符串）
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+        }
+        try {
+            // 从JSON对象中获取名为"folder"的JSONObject（通过GTaskStringUtils类中的常量）
+            JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            // 如果"folder"对象中的"type"键对应的值等于Notes.TYPE_FOLDER（此处Notes类和TYPE_FOLDER的定义未给出）
+            if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+                // 从"folder"对象中获取"SNIPPET"键对应的值作为名称，并添加特定前缀（通过GTaskStringUtils类中的常量）
+                String name = folder.getString(NoteColumns.SNIPPET);
+                setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
+            } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                // 如果"folder"对象中的"id"键对应的值等于特定的根文件夹ID（Notes.ID_ROOT_FOLDER，此处Notes类和ID_ROOT_FOLDER的定义未给出）
+                if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
+                    // 设置任务列表名称为特定前缀（通过GTaskStringUtils类中的常量）加上默认文件夹名称（通过GTaskStringUtils类中的常量）
+                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
+                // 如果"folder"对象中的"id"键对应的值等于特定的通话记录文件夹ID（Notes.ID_CALL_RECORD_FOLDER，此处Notes类和ID_CALL_RECORD_FOLDER的定义未给出）
+                else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
+                    // 设置任务列表名称为特定前缀（通过GTaskStringUtils类中的常量）加上通话记录文件夹名称（通过GTaskStringUtils类中的常量）
+                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                            + GTaskStringUtils.FOLDER_CALL_NOTE);
+                else
+                    // 如果"folder"对象的ID不匹配上述情况，记录错误日志（使用Log.e，标签为TAG，内容为指定的字符串）
+                    Log.e(TAG, "invalid system folder");
+            } else {
+                // 如果"folder"对象中的"type"键对应的值不是上述情况，记录错误日志（使用Log.e，标签为TAG，内容为指定的字符串）
+                Log.e(TAG, "error type");
+            }
+        } catch (JSONException e) {
+            // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+        }
+    }
+    // 从任务列表内容生成本地JSONObject的方法
+    public JSONObject getLocalJSONFromContent() {
+        try {
+            // 创建一个新的JSONObject实例
+            JSONObject js = new JSONObject();
+            // 创建一个名为"folder"的新JSONObject实例
+            JSONObject folder = new JSONObject();
+            // 获取任务列表名称
+            String folderName = getName();
+            // 如果任务列表名称以特定前缀（通过GTaskStringUtils类中的常量）开头
+            if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
+                // 去除前缀
+                folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
+                        folderName.length());
+            // 在"folder"对象中设置"SNIPPET"键值对，值为处理后的名称
+            folder.put(NoteColumns.SNIPPET, folderName);
+            // 如果处理后的名称等于默认文件夹名称（通过GTaskStringUtils类中的常量）或者通话记录文件夹名称（通过GTaskStringUtils类中的常量）
+            if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
+                    || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
+                // 在"folder"对象中设置"type"键值对，值为Notes.TYPE_SYSTEM（此处Notes类和TYPE_SYSTEM的定义未给出）
+                folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+            else
+                // 在"folder"对象中设置"type"键值对，值为Notes.TYPE_FOLDER（此处Notes类和TYPE_FOLDER的定义未给出）
+                folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+
+            // 在主JSON对象（js）中设置"folder"键值对，值为刚才创建的"folder"对象
+            js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
+            return js;
+        } catch (JSONException e) {
+            // 如果发生JSONException，记录错误日志（使用Log.e，标签为TAG，内容为异常的字符串表示）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+            return null;
+        }
+    }
+    // 根据数据库游标确定同步操作类型的方法。参数c是一个数据库游标对象
+    public int getSyncAction(Cursor c) {
+        try {
+            // 如果本地没有更新（通过检查数据库游标中的本地修改标志列，值为0表示无本地修改）
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
+                // 如果数据库中的同步ID与任务列表的最后修改时间匹配
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // 两边都无更新，返回无操作类型（SYNC_ACTION_NONE的值未给出，应该是一个预定义的表示无操作的常量）
+                    return SYNC_ACTION_NONE;
+                } else {
+                    // 将远程数据应用到本地，返回更新本地操作类型（SYNC_ACTION_UPDATE_LOCAL的值未给出，应该是一个预定义的表示更新本地操作的常量）
+                    return SYNC_ACTION_UPDATE_LOCAL;
+                }
+            } else {
+                // 验证gtask id是否匹配，即数据库游标中的gtask id与任务列表的ID（通过getGid()方法获取）是否相等
+                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
+                    Log.e(TAG, "gtask id doesn't match");
+                    return SYNC_ACTION_ERROR;
+                }
+                // 如果数据库中的同步ID与任务列表的最后修改时间匹配
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // 仅有本地修改，返回更新远程操作类型（SYNC_ACTION_UPDATE_REMOTE的值未给出，应该是一个预定义的表示更新远程操作的常量）
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                } else {
+                    // 对于文件夹冲突，直接应用本地修改（这里返回更新远程操作类型，可能与业务逻辑相关）
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                }
+            }
+        } catch (Exception e) {
+            // 如果发生任何异常，记录错误日志（包含异常信息）
+            Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
+            e.printStackTrace();
+        }
+        // 如果在方法执行过程中出现错误，返回错误操作类型（SYNC_ACTION_ERROR的值未给出，应该是一个预定义的表示错误操作的常量）
+        return SYNC_ACTION_ERROR;
+    }
+    // 获取任务列表中Task对象的数量的方法
+    public int getChildTaskCount() {
+        return mChildren.size();
+    }
+    // 向任务列表中添加一个Task对象的方法。参数task是要添加的Task对象
+    public boolean addChildTask(Task task) {
+        boolean ret = false;
+        // 如果task不为null且任务列表中不包含该task
+        if (task!= null &&!mChildren.contains(task)) {
+            // 将task添加到mChildren列表中，并将添加操作的结果赋值给ret
+            ret = mChildren.add(task);
+            if (ret) {
+                // 如果添加成功，需要设置task的前一个兄弟任务和父任务
+                task.setPriorSibling(mChildren.isEmpty()? null : mChildren
+                       .get(mChildren.size() - 1));
+                task.setParent(this);
+            }
+        }
+        return ret;
+    }
+    // 在指定索引位置向任务列表中添加一个Task对象的方法。参数task是要添加的Task对象，index是添加的索引位置
+    public boolean addChildTask(Task task, int index) {
+        // 如果索引小于0或者大于任务列表中Task对象的数量，记录错误日志并返回false
+        if (index < 0 || index > mChildren.size()) {
+            Log.e(TAG, "add child task: invalid index");
+            return false;
+        }
+        int pos = mChildren.indexOf(task);
+        // 如果task不为null且任务列表中不包含该task（pos == -1表示不包含）
+        if (task!= null && pos == -1) {
+            // 在指定索引位置将task添加到mChildren列表中
+        // 在指定索引位置向任务列表中添加任务task
+mChildren.add(index, task);
+// 更新任务列表
+// 初始化前一个任务为null
+Task preTask = null;
+// 初始化后一个任务为null
+Task afterTask = null;
+// 如果索引不为当前0，获取索引前一个位置的任务
+if (index!= 0)
+    preTask = mChildren.get(index - 1);
+// 如果索引不是列表中最后一个位置，获取当前索引后一个位置的任务
+if (index!= mChildren.size() - 1)
+    afterTask = mChildren.get(index + 1);
+// 设置task的前一个兄弟任务为preTask
+task.setPriorSibling(preTask);
+// 如果afterTask不为null，设置afterTask的前一个兄弟任务为task
+if (afterTask!= null)
+    afterTask.setPriorSibling(task);
+}
+// 返回添加操作是否成功的结果
+return true;
+}
+// 从任务列表中移除指定的task的方法
+public boolean removeChildTask(Task task) {
+    // 用于记录移除操作是否成功，初始化为false
+    boolean ret = false;
+    // 获取task在mChildren列表中的索引
+    int index = mChildren.indexOf(task);
+    // 如果索引不为 -1，表示task在列表中
+    if (index!= -1) {
+        // 尝试从mChildren列表中移除task，并将结果赋值给ret
+        ret = mChildren.remove(task);
+        // 如果移除成功
+        if (ret) {
+            // 重置task的前一个兄弟任务和父任务为null
+            task.setPriorSibling(null);
+            task.setParent(null);
+            // 更新任务列表
+            // 如果索引不是列表的大小（即不是最后一个元素）
+            if (index!= mChildren.size()) {
+                // 获取当前索引位置的任务，并设置其前一个兄弟任务
+                // 如果索引为0，则前一个兄弟任务为null，否则为前一个位置的任务
+                mChildren.get(index).setPriorSibling(
+                        index == 0? null : mChildren.get(index - 1));
+            }
+        }
+    }
+    // 返回移除操作是否成功的结果
+    return ret;
+}
+// 将指定的task移动到指定索引位置的方法
+public boolean moveChildTask(Task task, int index) {
+    // 如果索引小于0或者大于等于任务列表中任务的数量，记录错误日志并返回false
+    if (index < 0 || index >= mChildren.size()) {
+        Log.e(TAG, "move child task: invalid index");
+        return false;
+    }
+    // 获取task在mChildren列表中的位置
+    int pos = mChildren.indexOf(task);
+    // 如果task不在列表中，记录错误日志并返回false
+    if (pos == -1) {
+        Log.e(TAG, "move child task: the task should in the list");
+        return false;
+    }
+    // 如果task当前位置和目标索引相同，直接返回true
+    if (pos == index)
+        return true;
+    // 先移除task，再在指定索引处添加task，并返回操作结果
+    return (removeChildTask(task) && addChildTask(task, index));
+}
+// 根据给定的gid在任务列表中查找任务的方法
+public Task findChildTaskByGid(String gid) {
+    // 遍历任务列表中的每个任务
+    for (int i = 0; i < mChildren.size(); i++) {
+        // 获取当前索引位置的任务
+        Task t = mChildren.get(i);
+        // 如果任务的gid与给定的gid相等，返回该任务
+        if (t.getGid().equals(gid)) {
+            return t;
+        }
+    }
+    // 如果未找到匹配的任务，返回null
+    return null;
+}
+// 获取指定task在任务列表中的索引的方法
+public int getChildTaskIndex(Task task) {
+    // 通过mChildren列表的indexOf方法获取task的索引并返回
+    return mChildren.indexOf(task);
+}
+// 根据给定索引获取任务列表中任务的方法
+public Task getChildTaskByIndex(int index) {
+    // 如果索引小于0或者大于等于任务列表中任务的数量，记录错误日志并返回null
+    if (index < 0 || index >= mChildren.size()) {
+        Log.e(TAG, "getTaskByIndex: invalid index");
+        return null;
+    }
+    // 返回指定索引位置的任务
+    return mChildren.get(index);
+}
+// 根据给定的gid在任务列表中查找任务的方法（与findChildTaskByGid功能类似）
+public Task getChilTaskByGid(String gid) {
+    // 遍历任务列表中的每个任务
+    for (Task task : mChildren) {
+        // 如果任务的gid与给定的gid相等，返回该任务
+        if (task.getGid().equals(gid))
+            return task;
+    }
+    // 如果未找到匹配的任务，返回null
+    return null;
+}
+// 获取任务列表中所有任务的列表（即mChildren）的方法
+public ArrayList<Task> getChildTaskList() {
+    return this.mChildren;
+}
+// 设置任务列表索引的方法，参数index为要设置的索引值
+public void setIndex(int index) {
+    this.mIndex = index;
+}
+// 获取任务列表索引的方法
+public int getIndex() {
+    return this.mIndex;
+}

src/net/micode/notes/gtask/exception/ActionFailureException.java

@@ -0,0 +1,45 @@
+/*
+ * 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.
+ */
+// 版权声明：2010-2011年，MiCode开源社区（www.micode.net）
+// 根据Apache License 2.0（“许可证”）授权；
+// 除非遵守许可证，否则不得使用此文件。
+// 您可以在以下网址获得许可证：
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+// 除非适用法律要求或书面同意，根据许可证分发的软件按“原样”分发，
+// 不提供任何明示或暗示的保证或条件。
+// 请参阅控制权限和限制的许可证具体语言。
+package net.micode.notes.gtask.exception;
+// 定义包名为net.micode.notes.gtask.exception。
+public class ActionFailureException extends RuntimeException {
+    private static final long serialVersionUID = 4425249765923293627L;
+    // 定义一个公共类ActionFailureException，它继承自RuntimeException。
+    // 定义一个私有的静态最终字段serialVersionUID，值为4425249765923293627L。
+
+    public ActionFailureException() {
+        super();
+    }
+    // 定义ActionFailureException类的无参数构造函数，调用父类的无参数构造函数。
+    public ActionFailureException(String paramString) {
+        super(paramString);
+    }
+    // 定义ActionFailureException类的一个构造函数，接收一个字符串参数paramString，并将其传递给父类的构造函数。
+    public ActionFailureException(String paramString, Throwable paramThrowable) {
+        super(paramString, paramThrowable);
+    }
+    // 定义ActionFailureException类的一个构造函数，接收一个字符串参数paramString和一个Throwable类型的参数paramThrowable，并将它们传递给父类的构造函数。
+}

src/net/micode/notes/gtask/exception/NetworkFailureException.java

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+// 版权声明：2010-2011年，MiCode开源社区（www.micode.net）
+// 根据Apache License 2.0（“许可证”）授权；
+// 除非遵守许可证，否则不得使用此文件。
+// 您可以在以下网址获得许可证：
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+// 除非适用法律要求或书面同意，根据许可证分发的软件按“原样”分发，
+// 不提供任何明示或暗示的保证或条件。
+// 请参阅控制权限和限制的许可证具体语言。
+package net.micode.notes.gtask.exception;
+// 定义包名为net.micode.notes.gtask.exception。
+public class NetworkFailureException extends Exception {
+    private static final long serialVersionUID = 2107610287180234136L;
+    // 定义一个公共类NetworkFailureException，它继承自Exception。
+    // 定义一个私有的静态最终字段serialVersionUID，值为2107610287180234136L。
+    public NetworkFailureException() {
+        super();
+    }
+    // 定义NetworkFailureException类的无参数构造函数，调用父类的无参数构造函数。
+    public NetworkFailureException(String paramString) {
+        super(paramString);
+    }
+    // 定义NetworkFailureException类的一个构造函数，接收一个字符串参数paramString，并将其传递给父类的构造函数。
+    public NetworkFailureException(String paramString, Throwable paramThrowable) {
+        super(paramString, paramThrowable);
+    }
+    // 定义NetworkFailureException类的一个构造函数，接收一个字符串参数paramString和一个Throwable类型的参数paramThrowable，并将它们传递给父类的构造函数。
+}

src/net/micode/notes/gtask/remote/GTaskASyncTask.java

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ * 版权所有，MiCode开源社区。
+ */
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * 根据Apache License 2.0版本（“许可证”）授权；
+ */
+/**
+ * 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
+ * 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.gtask.remote; // 定义类的包名。
+import android.app.Notification; // 导入Notification类。
+import android.app.NotificationManager; // 导入NotificationManager类。
+import android.app.PendingIntent; // 导入PendingIntent类。
+import android.content.Context; // 导入Context类。
+import android.content.Intent; // 导入Intent类。
+import android.os.AsyncTask; // 导入AsyncTask类。
+import net.micode.notes.R; // 导入应用资源。
+import net.micode.notes.ui.NotesListActivity; // 导入NotesListActivity。
+import net.micode.notes.ui.NotesPreferenceActivity; // 导入NotesPreferenceActivity。
+public class GTaskASyncTask extends AsyncTask<Void, String, Integer> { // 定义异步任务类。
+    private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; // 同步通知的ID。
+
+    public interface OnCompleteListener { // 定义任务完成的监听器接口。
+        void onComplete(); // 当任务完成时调用的方法。
+    }
+    private Context mContext; // 存储上下文对象。
+    private NotificationManager mNotifiManager; // 存储通知管理器对象。
+    private GTaskManager mTaskManager; // 存储GTask管理器对象。
+    private OnCompleteListener mOnCompleteListener; // 存储任务完成监听器对象。
+
+    public GTaskASyncTask(Context context, OnCompleteListener listener) { // 构造函数。
+        mContext = context; // 初始化上下文对象。
+        mOnCompleteListener = listener; // 初始化任务完成监听器对象。
+        mNotifiManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE); // 获取通知管理器服务。
+        mTaskManager = GTaskManager.getInstance(); // 获取GTask管理器实例。
+    }
+
+    public void cancelSync() { // 提供取消同步的方法。
+        mTaskManager.cancelSync(); // 调用GTask管理器的取消同步方法。
+    }
+    public void publishProgess(String message) { // 提供发布进度的方法。
+        publishProgress(new String[] { message }); // 发布包含消息的进度。
+    }
+ private void showNotification(int tickerId, String content) { // 私有方法，显示通知。
+        Notification notification = new Notification(R.drawable.notification, mContext.getString(tickerId), System.currentTimeMillis()); // 创建通知对象。
+        notification.defaults = Notification.DEFAULT_LIGHTS; // 设置通知的默认灯光。
+        notification.flags = Notification.FLAG_AUTO_CANCEL; // 设置通知的自动取消标志。
+        PendingIntent pendingIntent; // 声明PendingIntent对象。
+        if (tickerId != R.string.ticker_success) { // 如果通知ID不是成功ID。
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, NotesPreferenceActivity.class), 0); // 创建PendingIntent，指向设置活动。
+        } else { // 否则。
+            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext, NotesListActivity.class), 0); // 创建PendingIntent，指向笔记列表活动。
+        }
+        notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content, pendingIntent); // 设置通知的最新事件信息。
+        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); // 发送通知。
+    }
+   @Override
+    protected Integer doInBackground(Void... unused) { // 重写doInBackground方法，执行后台任务。
+        publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity.getSyncAccountName(mContext))); // 发布登录进度。
+        return mTaskManager.sync(mContext, this); // 执行同步操作并返回结果。
+    }
+    @Override
+    protected void onProgressUpdate(String... progress) { // 重写onProgressUpdate方法，处理进度更新。
+        showNotification(R.string.ticker_syncing, progress[0]); // 显示同步中的通知。
+        if (mContext instanceof GTaskSyncService) { // 如果上下文是GTaskSyncService的实例。
+            ((GTaskSyncService) mContext).sendBroadcast(progress[0]); // 发送进度广播。
+        }
+    }
+    @Override
+    protected void onPostExecute(Integer result) { // 重写onPostExecute方法，处理任务执行完毕后的操作。
+        if (result == GTaskManager.STATE_SUCCESS) { // 如果结果是成功的。
+            showNotification(R.string.ticker_success, mContext.getString(R.string.success_sync_account, mTaskManager.getSyncAccount())); // 显示成功通知。
+            NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); // 设置最后同步时间。
+        } else if (result == GTaskManager.STATE_NETWORK_ERROR) { // 如果结果是网络错误的。
+            showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); // 显示网络错误通知。
+        } else if (result == GTaskManager.STATE_INTERNAL_ERROR) { // 如果结果是内部错误的。
+            showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); // 显示内部错误通知。
+        } else if (result == GTaskManager.STATE_SYNC_CANCELLED) { // 如果结果是同步被取消的。
+            showNotification(R.string.ticker_cancel, mContext.getString(R.string.error_sync_cancelled)); // 显示同步取消通知。
+        }
+        if (mOnCompleteListener != null) { // 如果有完成监听器。
+            new Thread(new Runnable() { // 创建新线程。
+                public void run() { // 运行任务完成监听器的onComplete方法。
+                    mOnCompleteListener.onComplete(); // 调用onComplete方法。
+                }
+            }).start(); // 启动线程。
+        }
+    }
+}

src/net/micode/notes/gtask/remote/GTaskClient.java

@@ -0,0 +1,163 @@
+/*
+ * 版权所有 (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ * 根据Apache License, Version 2.0（“许可证”）授权；
+ * 你可以在遵守许可证的情况下使用此文件。
+ * 你可以在以下网址获得许可证的副本：
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ * 除非适用法律要求或书面同意，否则按“原样”分发的软件
+ * 没有任何形式的担保或条件，无论是明示或暗示。
+ * 请参阅控制权限和
+ * 许可证下的限制。
+ */
+package net.micode.notes.gtask.remote; // 定义包名
+import android.accounts.Account; // 导入Account类
+import android.accounts.AccountManager; // 导入AccountManager类
+import android.accounts.AccountManagerFuture; // 导入AccountManagerFuture类
+import android.app.Activity; // 导入Activity类
+import android.os.Bundle; // 导入Bundle类
+import android.text.TextUtils; // 导入TextUtils类
+import android.util.Log; // 导入Log类
+import net.micode.notes.gtask.data.Node; // 导入Node类
+import net.micode.notes.gtask.data.Task; // 导入Task类
+import net.micode.notes.gtask.data.TaskList; // 导入TaskList类
+import net.micode.notes.gtask.exception.ActionFailureException; // 导入ActionFailureException类
+import net.micode.notes.gtask.exception.NetworkFailureException; // 导入NetworkFailureException类
+import net.micode.notes.tool.GTaskStringUtils; // 导入GTaskStringUtils工具类
+import net.micode.notes.ui.NotesPreferenceActivity; // 导入NotesPreferenceActivity类
+import org.apache.http.HttpEntity; // 导入HttpEntity类
+import org.apache.http.HttpResponse; // 导入HttpResponse类
+import org.apache.http.client.ClientProtocolException; // 导入ClientProtocolException类
+import org.apache.http.client.entity.UrlEncodedFormEntity; // 导入UrlEncodedFormEntity类
+import org.apache.http.client.methods.HttpGet; // 导入HttpGet类
+import org.apache.http.client.methods.HttpPost; // 导入HttpPost类
+import org.apache.http.cookie.Cookie; // 导入Cookie类
+import org.apache.http.impl.client.BasicCookieStore; // 导入BasicCookieStore类
+import org.apache.http.impl.client.DefaultHttpClient; // 导入DefaultHttpClient类
+import org.apache.http.message.BasicNameValuePair; // 导入BasicNameValuePair类
+import org.apache.http.params.BasicHttpParams; // 导入BasicHttpParams类
+import org.apache.http.params.HttpConnectionParams; // 导入HttpConnectionParams类
+import org.apache.http.params.HttpParams; // 导入HttpParams类
+import org.apache.http.params.HttpProtocolParams; // 导入HttpProtocolParams类
+import org.json.JSONArray; // 导入JSONArray类
+import org.json.JSONException; // 导入JSONException类
+import org.json.JSONObject; // 导入JSONObject类
+import java.io.BufferedReader; // 导入BufferedReader类
+import java.io.IOException; // 导入IOException类
+import java.io.InputStream; // 导入InputStream类
+import java.io.InputStreamReader; // 导入InputStreamReader类
+import java.util.LinkedList; // 导入LinkedList类
+import java.util.List; // 导入List类
+import java.util.zip.GZIPInputStream; // 导入GZIPInputStream类
+import java.util.zip.Inflater; // 导入Inflater类
+import java.util.zip.InflaterInputStream; // 导入InflaterInputStream类
+public class GTaskClient {
+    private static final String TAG = GTaskClient.class.getSimpleName(); // TAG用于日志记录
+    private static final String GTASK_URL = "https://mail.google.com/tasks/"; // Google Tasks的URL
+    private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig"; // 获取任务列表的URL
+    private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig"; // 提交任务更新的URL
+    private static GTaskClient mInstance = null; // GTaskClient的单例对象
+    private DefaultHttpClient mHttpClient; // HTTP客户端
+    private String mGetUrl; // GET请求的URL
+    private String mPostUrl; // POST请求的URL
+    private long mClientVersion; // 客户端版本号
+    private boolean mLoggedin; // 是否已经登录
+    private long mLastLoginTime; // 上次登录时间
+    private int mActionId; // 动作ID
+    private Account mAccount; // 当前使用的账户
+    private JSONArray mUpdateArray; // 更新数组
+    private GTaskClient() {
+        mHttpClient = null; // 初始化HTTP客户端为null
+        mGetUrl = GTASK_GET_URL; // 设置GET请求的URL
+        mPostUrl = GTASK_POST_URL; // 设置POST请求的URL
+        mClientVersion = -1; // 初始化客户端版本号为-1
+        mLoggedin = false; // 初始化登录状态为false
+        mLastLoginTime = 0; // 初始化上次登录时间为0
+        mActionId = 1; // 初始化动作ID为1
+        mAccount = null; // 初始化账户为null
+        mUpdateArray = null; // 初始化更新数组为null
+    }
+    public static synchronized GTaskClient getInstance() { // 获取GTaskClient实例的方法
+        if (mInstance == null) { // 如果实例为null
+            mInstance = new GTaskClient(); // 创建新的GTaskClient实例
+        }
+        return mInstance; // 返回GTaskClient实例
+    }
+    public boolean login(Activity activity) { // 登录方法
+        // 假设cookie在5分钟后过期，需要重新登录
+        final long interval = 1000 * 60 * 5;
+        if (mLastLoginTime + interval < System.currentTimeMillis()) {
+            mLoggedin = false; // 更新登录状态为false
+        }
+        // 账户切换后需要重新登录
+        if (mLoggedin
+                && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
+                        .getSyncAccountName(activity))) {
+            mLoggedin = false; // 更新登录状态为false
+        }
+        if (mLoggedin) { // 如果已经登录
+            Log.d(TAG, "already logged in"); // 打印日志
+            return true; // 返回true
+        }
+        mLastLoginTime = System.currentTimeMillis(); // 更新上次登录时间为当前时间
+        String authToken = loginGoogleAccount(activity, false); // 获取Google账户的认证令牌
+        if (authToken == null) { // 如果认证令牌为null
+            Log.e(TAG, "login google account failed"); // 打印错误日志
+            return false; // 返回false
+        }
+        // 如有必要，使用自定义域名登录
+        if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
+                .endsWith("googlemail.com"))) {
+            StringBuilder url = new StringBuilder(GTASK_URL).append("a/"); // 构建URL
+            int index = mAccount.name.indexOf('@') + 1; // 获取域名的起始位置
+            String suffix = mAccount.name.substring(index); // 获取域名
+            url.append(suffix + "/"); // 添加域名到URL
+            mGetUrl = url.toString() + "ig"; // 设置GET请求的URL
+            mPostUrl = url.toString() + "r/ig"; // 设置POST请求的URL
+
+            if (tryToLoginGtask(activity, authToken)) { // 尝试登录Gtask
+                mLoggedin = true; // 更新登录状态为true
+            }
+        }
+        // 尝试使用Google官方URL登录
+        if (!mLoggedin) { // 如果还未登录
+            mGetUrl = GTASK_GET_URL; // 设置GET请求的URL为官方URL
+            mPostUrl = GTASK_POST_URL; // 设置POST请求的URL为官方URL
+            if (!tryToLoginGtask(activity, authToken)) { // 尝试登录Gtask
+                return false; // 如果登录失败，返回false
+            }
+        }
+        mLoggedin = true; // 更新登录状态为true
+        return true; // 返回true
+    }
+    private String loginGoogleAccount(Activity activity, boolean invalidateToken) { // 获取Google账户的认证令牌
+        String authToken; // 认证令牌
+        AccountManager accountManager = AccountManager.get(activity); // 获取AccountManager实例
+        Account[] accounts = accountManager.getAccountsByType("com.google"); // 获取所有Google账户
+
+        if (accounts.length == 0) { // 如果没有Google账户
+            Log.e(TAG, "there is no available google account"); // 打印错误日志
+            return null; // 返回null
+        }
+        String accountName = NotesPreferenceActivity.getSyncAccountName(activity); // 获取同步账户名称
+        Account account = null; // 声明账户变量
+        for (Account a : accounts) { // 遍历所有账户
+            if (a.name.equals(accountName)) { // 如果找到匹配的账户
+                account = a; // 设置找到的账户
+                break; // 退出循环
+            }
+        }
+        if (account != null) { // 如果找到账户
+            mAccount = account; // 设置当前账户
+        } else { // 如果未找到账户
+                      Log.e(TAG, e.toString()); // 打印错误日志，记录异常信息
+            e.printStackTrace(); // 输出异常的堆栈跟踪信息
+            throw new ActionFailureException("get task list: handing jsonobject failed"); // 抛出ActionFailureException，表示处理JSONObject失败
+        }
+    }
+    public Account getSyncAccount() { // 获取同步账户的方法
+        return mAccount; // 返回当前账户
+    }
+    public void resetUpdateArray() { // 重置更新数组的方法
+        mUpdateArray = null; // 将更新数组设置为null
+    }
+}

src/net/micode/notes/gtask/remote/GTaskManager.java

@@ -0,0 +1,882 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.mcode.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.
+ */
+// 版权所有 (c) 2010-2011，MiCode开源社区（www.mcode.net）
+// 根据Apache License, Version 2.0（“许可证”）授权；
+// 除非遵守许可证，否则不得使用此文件。
+// 你可以在以下网址获得许可证的副本：
+//         http://www.apache.org/licenses/LICENSE-2.0
+// 除非适用法律要求或书面同意，否则按“原样”分发的软件
+// 没有明示或暗示的任何形式的保证，包括但不限于对适销性、特定用途适用性
+// 的暗示保证。请参阅许可证，了解有关权限和限制的具体语言控制。
+package net.micode.notes.gtask.remote;
+// 这是定义GTaskManager类的包
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.util.Log;
+// 导入Android SDK中用于数据库操作和日志记录的类
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.data.MetaData;
+import net.micode.notes.gtask.data.Node;
+import net.micode.notes.gtask.data.SqlNote;
+import net.micode.notes.gtask.data.Task;
+import net.micode.notes.gtask.data.TaskList;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.gtask.exception.NetworkFailureException;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.GTaskStringUtils;
+// 导入项目中定义的数据模型和工具类
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+// 导入Java标准库中的集合框架，用于存储和管理数据
+public class GTaskManager {
+    private static final String TAG = GTaskManager.class.getSimpleName();
+    // 定义一个常量TAG，用于日志输出时标识类名，通过getSimpleName()获取类名字符串
+    public static final int STATE_SUCCESS = 0;
+    public static final int STATE_NETWORK_ERROR = 1;
+    public static final int STATE_INTERNAL_ERROR = 2;
+    public static final int STATE_SYNC_IN_PROGRESS = 3;
+    public static final int STATE_SYNC_CANCELLED = 4;
+    // 定义同步状态的常量，用于表示同步操作的结果
+    private static GTaskManager mInstance = null;
+    // 单例模式的实例变量，用于持有GTaskManager类的唯一实例
+    private Activity mActivity;
+    // 定义一个Activity类型的变量，用于存储当前的Activity上下文
+    private Context mContext;
+    // 定义一个Context类型的变量，用于存储当前的应用程序上下文
+    private ContentResolver mContentResolver;
+    // 定义一个ContentResolver类型的变量，用于访问和管理数据库中的数据
+    private boolean mSyncing;
+    // 定义一个布尔类型的变量，用于标记是否正在执行同步操作
+    private boolean mCancelled;
+    // 定义一个布尔类型的变量，用于标记同步操作是否被取消
+    private HashMap<String, TaskList> mGTaskListHashMap;
+    // 定义一个HashMap，用于存储任务列表，键是任务列表的ID，值是TaskList对象
+    private HashMap<String, Node> mGTaskHashMap;
+    // 定义一个HashMap，用于存储任务节点，键是任务节点的ID，值是Node对象
+    private HashMap<String, MetaData> mMetaHashMap;
+    // 定义一个HashMap，用于存储元数据，键是元数据的ID，值是MetaData对象
+    private TaskList mMetaList;
+    // 定义一个TaskList类型的变量，用于存储元数据列表
+    private HashSet<Long> mLocalDeleteIdMap;
+    // 定义一个HashSet，用于存储本地删除的ID
+    private HashMap<String, Long> mGidToNid;
+    // 定义一个HashMap，用于存储全局ID到本地ID的映射
+    private HashMap<Long, String> mNidToGid;
+    // 定义一个HashMap，用于存储本地ID到全局ID的映射
+    private GTaskManager() {
+        mSyncing = false;
+        mCancelled = false;
+        mGTaskListHashMap = new HashMap<String, TaskList>();
+        mGTaskHashMap = new HashMap<String, Node>();
+        mMetaHashMap = new HashMap<String, MetaData>();
+        mMetaList = null;
+        mLocalDeleteIdMap = new HashSet<Long>();
+        mGidToNid = new HashMap<String, Long>();
+        mNidToGid = new HashMap<Long, String>();
+    }
+    // 私有构造函数，初始化所有成员变量
+    public static synchronized GTaskManager getInstance() {
+        if (mInstance == null) {
+            mInstance = new GTaskManager();
+        }
+        return mInstance;
+    }
+    // 公共静态方法，用于获取GTaskManager类的唯一实例，实现单例模式
+    public synchronized void setActivityContext(Activity activity) {
+        mActivity = activity;
+    }
+    // 公共同步方法，用于设置当前的Activity上下文
+    public int sync(Context context, GTaskASyncTask asyncTask) {
+        if (mSyncing) {
+            Log.d(TAG, "Sync is in progress");
+            return STATE_SYNC_IN_PROGRESS;
+        }
+        mContext = context;
+        mContentResolver = mContext.getContentResolver();
+        mSyncing = true;
+        mCancelled = false;
+        mGTaskListHashMap.clear();
+        mGTaskHashMap.clear();
+        mMetaHashMap.clear();
+        mLocalDeleteIdMap.clear();
+        mGidToNid.clear();
+        mNidToGid.clear();
+        try {
+            GTaskClient client = GTaskClient.getInstance();
+            client.resetUpdateArray();
+
+            // 登录Google任务
+
+            if (!mCancelled) {
+                if (!client.login(mActivity)) {
+                    throw new NetworkFailureException("login google task failed");
+                }
+            }
+            // 从Google获取任务列表
+            asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
+            initGTaskList();
+            // 执行内容同步工作
+            asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
+            syncContent();
+        } catch (NetworkFailureException e) {
+            Log.e(TAG, e.toString());
+            return STATE_NETWORK_ERROR;
+        } catch (ActionFailureException e) {
+            Log.e(TAG, e.toString());
+            return STATE_INTERNAL_ERROR;
+        } catch (Exception e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return STATE_INTERNAL_ERROR;
+        } finally {
+            mGTaskListHashMap.clear();
+            mGTaskHashMap.clear();
+            mMetaHashMap.clear();
+            mLocalDeleteIdMap.clear();
+            mGidToNid.clear();
+            mNidToGid.clear();
+            mSyncing = false;
+        }
+
+        return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
+    }
+    // 公共同步方法，用于执行同步操作，接收上下文和异步任务对象，返回同步状态
+
+    private void initGTaskList() throws NetworkFailureException {
+        if (mCancelled)
+            return;
+        GTaskClient client = GTaskClient.getInstance();
+        try {
+            JSONArray jsTaskLists = client.getTaskLists();
+            // 初始化元数据列表
+            mMetaList = null;
+            for (int i = 0; i < jsTaskLists.length(); i++) {
+                JSONObject object = jsTaskLists.getJSONObject(i);
+                String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+                String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
+                if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
+                    mMetaList = new TaskList();
+                    mMetaList.setContentByRemoteJSON(object);
+                    // 加载元数据
+                    JSONArray jsMetas = client.getTaskList(gid);
+                    for (int j = 0; j < jsMetas.length(); j++) {
+                        object = (JSONObject) jsMetas.getJSONObject(j);
+                        MetaData metaData = new MetaData();
+                        metaData.setContentByRemoteJSON(object);
+                        if (metaData.isWorthSaving()) {
+                            mMetaList.addChildTask(metaData);
+                            if (metaData.getGid() != null) {
+                                mMetaHashMap.put(metaData.getRelatedGid(), metaData);
+                            }
+                        }
+                    }
+                }
+            }
+            // 如果不存在，则创建元数据列表
+        if (mMetaList == null) {
+    mMetaList = new TaskList();
+    mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+            + GTaskStringUtils.FOLDER_META);
+    GTaskClient.getInstance().createTaskList(mMetaList);
+}
+// 如果mMetaList是空的，那么创建一个新的任务列表mMetaList，并设置其名称为MIUI_FOLDER_PREFFIX加上FOLDER_META。
+// 然后使用GTaskClient的实例创建这个任务列表。
+// 初始化任务列表
+for (int i = 0; i < jsTaskLists.length(); i++) {
+    JSONObject object = jsTaskLists.getJSONObject(i);
+    String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+    String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
+    if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)
+            && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                    + GTaskStringUtils.FOLDER_META)) {
+        TaskList tasklist = new TaskList();
+        tasklist.setContentByRemoteJSON(object);
+        mGTaskListHashMap.put(gid, tasklist);
+        mGTaskHashMap.put(gid, tasklist);
+        // 加载任务
+        JSONArray jsTasks = client.getTaskList(gid);
+        for (int j = 0; j < jsTasks.length(); j++) {
+            object = (JSONObject) jsTasks.getJSONObject(j);
+            gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+            Task task = new Task();
+            task.setContentByRemoteJSON(object);
+            if (task.isWorthSaving()) {
+                task.setMetaInfo(mMetaHashMap.get(gid));
+                tasklist.addChildTask(task);
+                mGTaskHashMap.put(gid, task);
+            }
+        }
+    }
+}
+// 捕获JSONException异常
+} catch (JSONException e) {
+    Log.e(TAG, e.toString());
+    e.printStackTrace();
+    throw new ActionFailureException("initGTaskList: handing JSONObject failed");
+}
+}
+private void syncContent() throws NetworkFailureException {
+    int syncType;
+    Cursor c = null;
+    String gid;
+    Node node;
+    mLocalDeleteIdMap.clear();
+    if (mCancelled) {
+        return;
+    }
+    // 对于本地已删除的笔记
+    try {
+        c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+                "(type<>? AND parent_id=?)", new String[] {
+                        String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
+                }, null);
+        if (c != null) {
+            while (c.moveToNext()) {
+                gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                node = mGTaskHashMap.get(gid);
+                if (node != null) {
+                    mGTaskHashMap.remove(gid);
+                    doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c);
+                }
+                mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+            }
+        } else {
+            Log.w(TAG, "failed to query trash folder");
+        }
+    } finally {
+        if (c != null) {
+            c.close();
+            c = null;
+        }
+    }
+    // 首先同步文件夹
+    syncFolder();
+    // 对于数据库中已存在的笔记
+    try {
+        c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+                "(type=? AND parent_id<>?)", new String[] {
+                        String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER)
+                }, NoteColumns.TYPE + " DESC");
+        if (c != null) {
+            while (c.moveToNext()) {
+                gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                node = mGTaskHashMap.get(gid);
+                if (node != null) {
+                    mGTaskHashMap.remove(gid);
+                    mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
+                    mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+                    syncType = node.getSyncAction(c);
+                } else {
+                    if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+                        // 本地添加
+                        syncType = Node.SYNC_ACTION_ADD_REMOTE;
+                    } else {
+                        // 远程删除
+                        syncType = Node.SYNC_ACTION_DEL_LOCAL;
+                    }
+                }
+                doContentSync(syncType, node, c);
+            }
+        } else {
+            Log.w(TAG, "failed to query existing note in database");
+        }
+    } finally {
+        if (c != null) {
+            c.close();
+            c = null;
+        }
+    }
+    // 遍历剩余项
+    Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
+    while (iter.hasNext()) {
+        Map.Entry<String, Node> entry = iter.next();
+        node = entry.getValue();
+        doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+    }
+    // mCancelled可以被另一个线程设置，因此我们需要逐个检查
+    // 清空本地删除表
+    if (!mCancelled) {
+        if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
+            throw new ActionFailureException("failed to batch-delete local deleted notes");
+        }
+    }
+    // 刷新本地同步ID
+    if (!mCancelled) {
+        GTaskClient.getInstance().commitUpdate();
+        refreshLocalSyncId();
+    }
+}
+private void syncFolder() throws NetworkFailureException {
+    Cursor c = null;
+    String gid;
+    Node node;
+    int syncType;
+    if (mCancelled) {
+        return;
+    }
+    // 对于根文件夹
+    try {
+        c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+                Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
+        if (c != null) {
+            c.moveToNext();
+            gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+            node = mGTaskHashMap.get(gid);
+            if (node != null) {
+                mGTaskHashMap.remove(gid);
+                mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
+                mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
+                // 对于系统文件夹，只有在必要时才更新远程名称
+                if (!node.getName().equals(
+                        GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
+                    doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+            } else {
+                doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+            }
+        } else {
+            Log.w(TAG, "failed to query root folder");
+        }
+    } finally {
+        if (c != null) {
+            c.close();
+            c = null;
+        }
+    }
+    // 对于通话记录文件夹
+    try {
+        c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
+                new String[] {
+                    String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
+                }, null);
+        if (c != null) {
+            if (c.moveToNext()) {
+                gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                node = mGTaskHashMap.get(gid);
+                if (node != null) {
+                    mGTaskHashMap.remove(gid);
+                    mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
+                    mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
+                    // 对于系统文件夹，只有在必要时才更新远程名称
+                    if (!node.getName().equals(
+                            GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                                    + GTaskStringUtils.FOLDER_CALL_NOTE))
+                        doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+                } else {
+                    doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+                }
+            }
+        } else {
+            Log.w(TAG, "failed to query call note folder");
+        }
+    } finally {
+        if (c != null) {
+            c.close();
+            c = null;
+        }
+    }
+    // 对于本地已存在的文件夹
+    try {
+        c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+                "(type=? AND parent_id<>?)", new String[] {
+                        String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)
+                }, NoteColumns.TYPE + " DESC");
+        if (c != null) {
+            while (c.moveToNext()) {
+                gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                node = mGTaskHashMap.get(gid);
+                if (node != null) {
+                    mGTaskHashMap.remove(gid);
+                    mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
+                    mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+                    syncType = node.getSyncAction(c);
+                } else {
+               if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+    // 本地添加操作
+    syncType = Node.SYNC_ACTION_ADD_REMOTE;
+} else {
+    // 远程删除操作
+    syncType = Node.SYNC_ACTION_DEL_LOCAL;
+}
+doContentSync(syncType, node, c);  // 执行同步操作
+} else {
+    Log.w(TAG, "failed to query existing note in database");  // 如果查询数据库中的现有笔记失败，则记录警告日志
+}
+} finally {
+    if (c != null) {
+        c.close();
+        c = null;
+    }
+}  // 确保在finally代码块中关闭游标c并释放资源
+
+// 遍历剩余项
+Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
+while (iter.hasNext()) {
+    Map.Entry<String, Node> entry = iter.next();
+    node = entry.getValue();
+    doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);  // 对于剩余的节点，执行同步操作，将节点添加到本地
+}
+// 如果mCancelled可以被另一个线程设置，因此我们需要逐个检查
+// 清空本地删除表
+if (!mCancelled) {
+    if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
+        throw new ActionFailureException("failed to batch-delete local deleted notes");  // 如果同步未被取消，尝试批量删除本地已删除的笔记，如果失败则抛出异常
+    }
+}
+// 刷新本地同步ID
+if (!mCancelled) {
+    GTaskClient.getInstance().commitUpdate();
+    refreshLocalSyncId();  // 如果同步未被取消，提交更新并刷新本地同步ID
+}
+private void syncFolder() throws NetworkFailureException {
+    Cursor c = null;
+    String gid;
+    Node node;
+    int syncType;
+
+    if (mCancelled) {
+        return;  // 如果同步已被取消，则直接返回
+    }
+    // 对于根文件夹
+    try {
+        c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+                Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
+        if (c != null) {
+            c.moveToNext();
+            gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+            node = mGTaskHashMap.get(gid);
+            if (node != null) {
+                mGTaskHashMap.remove(gid);
+                mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
+                mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
+                // 对于系统文件夹，只有在必要时才更新远程名称
+                if (!node.getName().equals(
+                        GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
+                    doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);  // 如果名称不是默认值，则执行远程更新同步操作
+            } else {
+                doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);  // 如果节点为空，则执行远程添加同步操作
+            }
+        } else {
+            Log.w(TAG, "failed to query root folder");  // 如果查询根文件夹失败，记录警告日志
+        }
+    } finally {
+        if (c != null) {
+            c.close();
+            c = null;
+        }
+    }  // 确保在finally代码块中关闭游标c并释放资源
+// 对于通话记录文件夹
+try {
+    c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
+            new String[] {
+                String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
+            }, null);
+    if (c != null) {
+        if (c.moveToNext()) {
+            gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+            node = mGTaskHashMap.get(gid);
+            if (node != null) {
+                mGTaskHashMap.remove(gid);
+                mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
+                mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
+                // 对于系统文件夹，只有在必要时才更新远程名称
+                if (!node.getName().equals(
+                        GTaskStringUtils.MIUI_FOLDER_PREFFIX
+                                + GTaskStringUtils.FOLDER_CALL_NOTE))
+                    doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+            } else {
+                doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+            }
+        }
+    } else {
+        Log.w(TAG, "failed to query call note folder");
+    }
+} finally {
+    if (c != null) {
+        c.close();
+        c = null;
+    }
+}
+// 对于本地已存在的文件夹
+try {
+    c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+            "(type=? AND parent_id<>?)", new String[] {
+                    String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)
+            }, NoteColumns.TYPE + " DESC");
+    if (c != null) {
+        while (c.moveToNext()) {
+            gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+            node = mGTaskHashMap.get(gid);
+            if (node != null) {
+                mGTaskHashMap.remove(gid);
+                mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
+                mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+                syncType = node.getSyncAction(c);
+            } else {
+                if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+                    // 本地添加
+                    syncType = Node.SYNC_ACTION_ADD_REMOTE;
+                } else {
+                    // 远程删除
+                    syncType = Node.SYNC_ACTION_DEL_LOCAL;
+                }
+            }
+            doContentSync(syncType, node, c);
+        }
+    } else {
+        Log.w(TAG, "failed to query existing folder");
+    }
+} finally {
+    if (c != null) {
+        c.close();
+        c = null;
+    }
+}
+// 对于远程添加的文件夹
+Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
+while (iter.hasNext()) {
+    Map.Entry<String, TaskList> entry = iter.next();
+    gid = entry.getKey();
+    node = entry.getValue();
+    if (mGTaskHashMap.containsKey(gid)) {
+        mGTaskHashMap.remove(gid);
+        doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+    }
+}
+// 如果没有被取消，则提交更新
+if (!mCancelled)
+    GTaskClient.getInstance().commitUpdate();
+}
+private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
+    if (mCancelled) {
+        return;  // 如果同步已被取消，则直接返回。
+    }
+    MetaData meta;
+    switch (syncType) {
+        case Node.SYNC_ACTION_ADD_LOCAL:
+            addLocalNode(node);  // 添加本地节点。
+            break;
+        case Node.SYNC_ACTION_ADD_REMOTE:
+            addRemoteNode(node, c);  // 添加远程节点。
+            break;
+        case Node.SYNC_ACTION_DEL_LOCAL:
+            meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));  // 获取元数据。
+            if (meta != null) {
+                GTaskClient.getInstance().deleteNode(meta);  // 删除远程节点。
+            }
+            mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));  // 添加到本地删除ID映射。
+            break;
+        case Node.SYNC_ACTION_DEL_REMOTE:
+            meta = mMetaHashMap.get(node.getGid());
+            if (meta != null) {
+                GTaskClient.getInstance().deleteNode(meta);  // 删除远程节点。
+            }
+            GTaskClient.getInstance().deleteNode(node);  // 删除远程节点。
+            break;
+        case Node.SYNC_ACTION_UPDATE_LOCAL:
+            updateLocalNode(node, c);  // 更新本地节点。
+            break;
+        case Node.SYNC_ACTION_UPDATE_REMOTE:
+            updateRemoteNode(node, c);  // 更新远程节点。
+            break;
+        case Node.SYNC_ACTION_UPDATE_CONFLICT:
+            // 合并修改可能是一个好主意，但现在我们简单地使用本地更新。
+            updateRemoteNode(node, c);
+            break;
+        case Node.SYNC_ACTION_NONE:
+            break;
+        case Node.SYNC_ACTION_ERROR:
+        default:
+            throw new ActionFailureException("unknown sync action type");  // 抛出未知同步操作类型的异常。
+    }
+}
+private void addLocalNode(Node node) throws NetworkFailureException {
+    if (mCancelled) {
+        return;  // 如果同步已被取消，则直接返回。
+    }
+    SqlNote sqlNote;
+    if (node instanceof TaskList) {
+        if (node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
+            sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);  // 创建根文件夹的SqlNote。
+        } else if (node.getName().equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
+            sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);  // 创建通话记录文件夹的SqlNote。
+        } else {
+            sqlNote = new SqlNote(mContext);  // 创建SqlNote。
+            sqlNote.setContent(node.getLocalJSONFromContent());  // 设置内容。
+            sqlNote.setParentId(Notes.ID_ROOT_FOLDER);  // 设置父ID为根文件夹。
+        }
+    } else {
+        sqlNote = new SqlNote(mContext);  // 创建SqlNote。
+        JSONObject js = node.getLocalJSONFromContent();  // 获取本地JSON内容。
+        try {
+            if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+                JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);  // 获取笔记。
+                if (note.has(NoteColumns.ID)) {
+                    long id = note.getLong(NoteColumns.ID);  // 获取ID。
+                    if (DataUtils.existInNoteDatabase(mContentResolver, id)) {  // 检查ID是否存在。
+                        // ID不可用，必须创建一个新的。
+                        note.remove(NoteColumns.ID);
+                    }
+                }
+            }
+            if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
+                JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);  // 获取数据数组。
+                for (int i = 0; i < dataArray.length(); i++) {
+                    JSONObject data = dataArray.getJSONObject(i);  // 获取数据。
+                    if (data.has(DataColumns.ID)) {
+                        long dataId = data.getLong(DataColumns.ID);  // 获取数据ID。
+                        if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {  // 检查数据ID是否存在。
+                            // 数据ID不可用，必须创建一个新的。
+                            data.remove(DataColumns.ID);
+                        }
+                    }
+                }
+            }
+        } catch (JSONException e) {
+            Log.w(TAG, e.toString());  // 记录警告日志。
+            e.printStackTrace();  // 打印堆栈跟踪。
+        }
+        sqlNote.setContent(js);  // 设置SqlNote的内容。
+
+        Long parentId = mGidToNid.get(((Task) node).getParent().getGid());  // 获取父ID。
+        if (parentId == null) {
+            Log.e(TAG, "cannot find task's parent id locally");  // 记录错误日志。
+            throw new ActionFailureException("cannot add local node");  // 抛出异常。
+        }
+        sqlNote.setParentId(parentId.longValue());  // 设置SqlNote的父ID。
+    }
+    // 创建本地节点。
+    sqlNote.setGtaskId(node.getGid());  // 设置SqlNote的GTask ID。
+    sqlNote.commit(false);  // 提交SqlNote。
+
+    // 更新gid-nid映射。
+    mGidToNid.put(node.getGid(), sqlNote.getId());  // 将GTask ID映射到本地ID。
+    mNidToGid.put(sqlNote.getId(), node.getGid());  // 将本地ID映射到GTask ID。
+    // 更新元数据。
+    updateRemoteMeta(node.getGid(), sqlNote);  // 更新远程元数据。
+}
+private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
+    if (mCancelled) {
+        return;  // 如果同步已被取消，则直接返回。
+    }
+    SqlNote sqlNote;  // 创建SqlNote。
+    sqlNote = new SqlNote(mContext, c);  // 从游标c创建SqlNote。
+    sqlNote.setContent(node.getLocalJSONFromContent());  // 设置SqlNote的内容。
+    Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid()) : new Long(Notes.ID_ROOT_FOLDER);  // 获取父ID。
+    if (parentId == null) {
+        Log.e(TAG, "cannot find task's parent id locally");  // 记录错误日志。
+        throw new ActionFailureException("cannot update local node");  // 抛出异常。
+    }
+    sqlNote.setParentId(parentId.longValue());  // 设置SqlNote的父ID。
+    sqlNote.commit(true);  // 提交SqlNote。
+    // 更新元数据信息。
+    updateRemoteMeta(node.getGid(), sqlNote);  // 更新远程元数据。
+}
+private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+    if (mCancelled) {
+        return;  // 如果同步已被取消，则直接返回。
+    }
+    SqlNote sqlNote = new SqlNote(mContext, c);  // 从游标c创建SqlNote。
+    Node n;
+    // 远程更新。
+    if (sqlNote.isNoteType()) {
+        Task task = new Task();  // 创建任务。
+        task.setContentByLocalJSON(sqlNote.getContent());  // 设置任务内容。
+        String parentGid = mNidToGid.get(sqlNote.getParentId());  // 获取父GID。
+        if (parentGid == null) {
+            Log.e(TAG, "cannot find task's parent tasklist");  // 记录错误日志。
+            throw new ActionFailureException("cannot add remote task");  // 抛出异常。
+        }
+        mGTaskListHashMap.get(parentGid).addChildTask(task);  // 添加任务到任务列表。
+        GTaskClient.getInstance().createTask(task);  // 创建远程任务。
+        n = (Node) task;  // 转换为节点。
+        // 添加元数据。
+        updateRemoteMeta(task.getGid(), sqlNote);  // 更新远程元数据。
+    } else {
+        TaskList tasklist = null;  // 创建任务列表。
+        // 如果文件夹已经存在，则跳过。
+        String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;  // 获取文件夹名称。
+        if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
+            folderName += GTaskStringUtils.FOLDER_DEFAULT;
+        else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER)
+            folderName += GTaskStringUtils.FOLDER_CALL_NOTE;
+        else
+            folderName += sqlNote.getSnippet();
+        Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();  // 迭代任务列表映射。
+        while (iter.hasNext()) {
+            Map.Entry<String, TaskList> entry = iter.next();  // 获取条目。
+            String gid = entry.getKey();  // 获取GID。
+            TaskList list = entry.getValue();  // 获取任务列表。
+            if (list.getName().equals(folderName)) {  // 如果任务列表名称匹配。
+                tasklist = list;  // 设置任务列表。
+                if (mGTaskHashMap.containsKey(gid)) {
+                    mGTaskHashMap.remove(gid);  // 从映射中移除。
+                }
+                break;  // 跳出循环。
+            }
+        }
+        // 如果没有匹配，现在可以添加。
+        if (tasklist == null) {
+            tasklist = new TaskList();  // 创建任务列表。
+            tasklist.setContentByLocalJSON(sqlNote.getContent());  // 设置任务列表内容
+            GTaskClient.getInstance().createTaskList(tasklist);
+	    // 创建远程任务列表。
+            mGTaskListHashMap.put(tasklist.getGid(), tasklist);
+            // 将新创建的任务列表的GID和对象存储到HashMap中。
+            n = (Node) tasklist;
+            // 将任务列表转换为节点对象。
+            // 更新本地笔记
+            sqlNote.setGtaskId(n.getGid());
+            // 设置SqlNote的GTask ID为节点的GID。
+            sqlNote.commit(false);
+            // 提交SqlNote，但不标记为已同步。
+            sqlNote.resetLocalModified();
+            // 重置本地修改标志。
+             sqlNote.commit(true);
+              // 提交SqlNote，标记为已同步。
+               // GID到本地ID的映射
+              mGidToNid.put(n.getGid(), sqlNote.getId());
+             // 将全局ID映射到本地ID。
+                  mNidToGid.put(sqlNote.getId(), n.getGid());
+                  // 将本地ID映射到全局ID。
+private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+    if (mCancelled) {
+        return;
+    }
+    // 如果同步被取消，则直接返回。
+    SqlNote sqlNote = new SqlNote(mContext, c);
+    // 根据上下文和游标创建SqlNote对象。
+    // 远程更新
+    node.setContentByLocalJSON(sqlNote.getContent());
+    // 将节点的内容设置为SqlNote的本地JSON内容。
+    GTaskClient.getInstance().addUpdateNode(node);
+    // 将更新的节点添加到远程任务列表。
+    // 更新元数据
+    updateRemoteMeta(node.getGid(), sqlNote);
+    // 根据节点的GID和SqlNote更新远程元数据。
+    // 如果需要，移动任务
+    if (sqlNote.isNoteType()) {
+        Task task = (Task) node;
+        // 将节点转换为任务对象。
+        TaskList preParentList = task.getParent();
+        // 获取任务的旧父列表。
+        String curParentGid = mNidToGid.get(sqlNote.getParentId());
+        // 获取新父列表的GID。
+        if (curParentGid == null) {
+            Log.e(TAG, "cannot find task's parent tasklist");
+            // 如果找不到父任务列表，记录错误日志。
+            throw new ActionFailureException("cannot update remote task");
+            // 抛出异常，无法更新远程任务。
+        }
+        TaskList curParentList = mGTaskListHashMap.get(curParentGid);
+        // 根据GID获取当前父列表。
+        if (preParentList != curParentList) {
+            // 如果旧父列表与新父列表不同，则移动任务。
+            preParentList.removeChildTask(task);
+            // 从旧父列表中移除任务。
+            curParentList.addChildTask(task);
+            // 将任务添加到新父列表。
+            GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
+            // 远程移动任务。
+        }
+    }
+    // 清除本地修改标志
+    sqlNote.resetLocalModified();
+    // 重置SqlNote的本地修改标志。
+    sqlNote.commit(true);
+    // 提交SqlNote，标记为已同步。
+}
+private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
+    if (sqlNote != null && sqlNote.isNoteType()) {
+        MetaData metaData = mMetaHashMap.get(gid);
+        // 根据GID获取元数据。
+        if (metaData != null) {
+            metaData.setMeta(gid, sqlNote.getContent());
+            // 设置元数据的内容。
+            GTaskClient.getInstance().addUpdateNode(metaData);
+            // 将更新的元数据添加到远程任务列表。
+        } else {
+            metaData = new MetaData();
+            metaData.setMeta(gid, sqlNote.getContent());
+            // 创建新的元数据，并设置内容。
+            mMetaList.addChildTask(metaData);
+            // 将元数据添加到元数据列表。
+            mMetaHashMap.put(gid, metaData);
+            // 将元数据添加到HashMap中，以GID为键。
+            GTaskClient.getInstance().createTask(metaData);
+            // 创建远程元数据任务。
+        }
+    }
+}
+private void refreshLocalSyncId() throws NetworkFailureException {
+    if (mCancelled) {
+        return;
+    }
+    // 如果同步被取消，则直接返回。
+    // 获取最新的gtask列表。
+    mGTaskHashMap.clear();
+    mGTaskListHashMap.clear();
+    mMetaHashMap.clear();
+    initGTaskList();
+    Cursor c = null;
+    try {
+        c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+                "(type<>? AND parent_id<>?)", new String[] {
+                        String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
+                }, NoteColumns.TYPE + " DESC");
+        // 查询数据库，获取非系统类型且非垃圾箱的笔记。
+        if (c != null) {
+            while (c.moveToNext()) {
+                String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+                Node node = mGTaskHashMap.get(gid);
+                if (node != null) {
+                    mGTaskHashMap.remove(gid);
+                    ContentValues values = new ContentValues();
+                    values.put(NoteColumns.SYNC_ID, node.getLastModified());
+                    mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+                            c.getLong(SqlNote.ID_COLUMN)), values, null, null);
+                } else {
+                    Log.e(TAG, "something is missed");
+                    throw new ActionFailureException(
+                            "some local items don't have gid after sync");
+                }
+            }
+        } else {
+            Log.w(TAG, "failed to query local note to refresh sync id");
+        }
+    } finally {
+        if (c != null) {
+            c.close();
+            c = null;
+        }
+    }
+}
+public String getSyncAccount() {
+    return GTaskClient.getInstance().getSyncAccount().name;
+    // 获取当前同步账户的名称。
+}
+public void cancelSync() {
+    mCancelled = true;
+    // 取消当前的同步操作。
+}

src/net/micode/notes/gtask/remote/GTaskSyncService.java

@@ -0,0 +1,113 @@
+/*
+ * 版权所有 (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ * 根据Apache License, Version 2.0（“许可证”）授权；
+ * 除非遵守许可证，否则不得使用此文件。
+ * 你可以在以下网址获得许可证的副本：
+ *        http://www.apache.org/licenses/LICENSE-2.0 
+ * 除非适用法律要求或书面同意，软件
+ * 按“原样”分发的基础上，没有任何形式的担保或条件，无论是明示或暗示。
+ * 请参阅控制权限和
+ * 许可证下的限制。
+ */
+package net.micode.notes.gtask.remote;
+import android.app.Activity;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.IBinder;
+public class GTaskSyncService extends Service {
+    // 定义同步服务中的常量
+    public final static String ACTION_STRING_NAME = "sync_action_type";
+    public final static int ACTION_START_SYNC = 0;
+    public final static int ACTION_CANCEL_SYNC = 1;
+    public final static int ACTION_INVALID = 2;
+    public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
+    public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
+    public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
+    private static GTaskASyncTask mSyncTask = null; // 定义同步任务实例
+    private static String mSyncProgress = ""; // 定义同步进度字符串
+    private void startSync() {
+        // 开始同步的方法
+        if (mSyncTask == null) {
+            mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
+                public void onComplete() {
+                    mSyncTask = null; // 完成后将同步任务设置为null
+                    sendBroadcast(""); // 发送广播
+                    stopSelf(); // 停止服务
+                }
+            });
+            sendBroadcast("");
+            mSyncTask.execute(); // 执行同步任务
+        }
+    }
+    private void cancelSync() {
+        // 取消同步的方法
+        if (mSyncTask != null) {
+            mSyncTask.cancelSync(); // 调用同步任务的取消方法
+        }
+    }
+    @Override
+    public void onCreate() {
+        mSyncTask = null; // 在服务创建时将同步任务设置为null
+    }
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        // 处理服务命令的方法
+        Bundle bundle = intent.getExtras();
+        if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
+            switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
+                case ACTION_START_SYNC:
+                    startSync(); // 开始同步
+                    break;
+                case ACTION_CANCEL_SYNC:
+                    cancelSync(); // 取消同步
+                    break;
+                default:
+                    break;
+            }
+            return START_STICKY; // 返回START_STICKY以保持服务运行
+        }
+        return super.onStartCommand(intent, flags, startId); // 调用父类的onStartCommand方法
+    }
+    @Override
+    public void onLowMemory() {
+        // 处理低内存情况的方法
+        if (mSyncTask != null) {
+            mSyncTask.cancelSync(); // 如果同步任务正在进行，则取消同步
+        }
+    }
+    public IBinder onBind(Intent intent) {
+        // 返回服务的绑定器，这里返回null表示服务不支持绑定
+        return null;
+    }
+    public void sendBroadcast(String msg) {
+        // 发送广播的方法
+        mSyncProgress = msg; // 更新同步进度字符串
+        Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); // 创建广播Intent
+        intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null); // 添加是否正在同步的额外信息
+        intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg); // 添加进度消息
+        sendBroadcast(intent); // 发送广播
+    }
+    public static void startSync(Activity activity) {
+        // 静态方法，用于从活动开始同步
+        GTaskManager.getInstance().setActivityContext(activity); // 设置GTaskManager的活动上下文
+        Intent intent = new Intent(activity, GTaskSyncService.class); // 创建Intent
+        intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC); // 添加开始同步的额外信息
+        activity.startService(intent); // 启动服务
+    }
+    public static void cancelSync(Context context) {
+        // 静态方法，用于取消同步
+        Intent intent = new Intent(context, GTaskSyncService.class); // 创建Intent
+        intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC); // 添加取消同步的额外信息
+        context.startService(intent); // 启动服务
+    }
+    public static boolean isSyncing() {
+        // 静态方法，用于检查是否正在同步
+        return mSyncTask != null; // 如果同步任务不为空，则返回true
+    }
+    public static String getProgressString() {
+        // 静态方法，用于获取同步进度字符串
+        return mSyncProgress; // 返回同步进度字符串
+    }
+}

src/net/micode/notes/model/Note.java

@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ */
+// 版权所有 (c) 2010-2011，MiCode开源社区（www.micode.net）
+
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ */
+// 根据Apache License, 版本2.0（“许可证”）授权；
+/*
+ * 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
+ */
+// 您可以在以下网址获得许可证的副本：
+//
+//        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;
+// 包名声明：net.micode.notes.model
+import android.content.ContentProviderOperation;
+// 导入ContentProviderOperation类
+import android.content.ContentProviderResult;
+// 导入ContentProviderResult类
+import android.content.ContentUris;
+// 导入ContentUris类
+import android.content.ContentValues;
+// 导入ContentValues类
+import android.content.Context;
+// 导入Context类
+import android.content.OperationApplicationException;
+// 导入OperationApplicationException类
+import android.net.Uri;
+// 导入Uri类
+import android.os.RemoteException; // 导入RemoteException类
+import android.util.Log; // 导入Log类
+import net.micode.notes.data.Notes;  // 导入Notes类
+import net.micode.notes.data.Notes.CallNote; // 导入CallNote类
+import net.micode.notes.data.Notes.DataColumns; // 导入DataColumns类
+import net.micode.notes.data.Notes.NoteColumns; // 导入NoteColumns类
+import net.micode.notes.data.Notes.TextNote; // 导入TextNote类
+import java.util.ArrayList; // 导入ArrayList类
+public class Note {
+    // 定义公共类Note
+    private ContentValues mNoteDiffValues;
+    // 定义私有成员变量mNoteDiffValues，类型为ContentValues
+    private NoteData mNoteData;
+    // 定义私有成员变量mNoteData，类型为NoteData
+    private static final String TAG = "Note";
+    // 定义私有静态常量TAG，值为"Note"，用于日志标记
+    /**
+     * Create a new note id for adding a new note to databases
+     */
+    // 创建一个新的笔记ID，用于将新笔记添加到数据库
+    public static synchronized long getNewNoteId(Context context, long folderId) {
+        // 定义公共静态同步方法getNewNoteId，接收Context和folderId作为参数，返回类型为long
+        ContentValues values = new ContentValues();
+        // 创建ContentValues对象values
+        long createdTime = System.currentTimeMillis();
+        // 获取当前系统时间毫秒数
+        values.put(NoteColumns.CREATED_DATE, createdTime);
+        // 将CREATED_DATE列的值设置为当前时间
+        values.put(NoteColumns.MODIFIED_DATE, createdTime);
+        // 将MODIFIED_DATE列的值设置为当前时间
+        values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+        // 将TYPE列的值设置为Notes.TYPE_NOTE
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        // 将LOCAL_MODIFIED列的值设置为1
+        values.put(NoteColumns.PARENT_ID, folderId);
+        // 将PARENT_ID列的值设置为folderId
+        Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
+        // 将values插入到Notes.CONTENT_NOTE_URI，并返回生成的Uri
+        long noteId = 0;
+        // 定义long型变量noteId并初始化为0
+        try {
+            noteId = Long.valueOf(uri.getPathSegments().get(1));
+        } catch (NumberFormatException e) {
+            Log.e(TAG, "Get note id error :" + e.toString());
+            noteId = 0;
+        }
+        // 尝试从Uri中获取noteId，如果发生NumberFormatException，则记录错误日志，并设置noteId为0
+        if (noteId == -1) {
+            throw new IllegalStateException("Wrong note id:" + noteId);
+        }
+        // 如果noteId为-1，则抛出IllegalStateException异常
+        return noteId;
+        // 返回noteId
+    }
+    public Note() {
+        mNoteDiffValues = new ContentValues();
+        mNoteData = new NoteData();
+    }
+    // 定义Note类的构造函数，初始化mNoteDiffValues和mNoteData
+    public void setNoteValue(String key, String value) {
+        mNoteDiffValues.put(key, value);
+        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+    }
+    // 定义公共方法setNoteValue，设置笔记的值，并标记为本地修改
+    public void setTextData(String key, String value) {
+        mNoteData.setTextData(key, value);
+    }
+    // 定义公共方法setTextData，设置文本数据
+    public void setTextDataId(long id) {
+        mNoteData.setTextDataId(id);
+    }
+    // 定义公共方法setTextDataId，设置文本数据ID
+    public long getTextDataId() {
+        return mNoteData.mTextDataId;
+    }
+    // 定义公共方法getTextDataId，返回文本数据ID
+    public void setCallDataId(long id) {
+        mNoteData.setCallDataId(id);
+    }
+    // 定义公共方法setCallDataId，设置通话数据ID
+    public void setCallData(String key, String value) {
+        mNoteData.setCallData(key, value);
+    }
+    // 定义公共方法setCallData，设置通话数据
+    public boolean isLocalModified() {
+        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
+    }
+    // 定义公共方法isLocalModified，检查笔记是否在本地被修改过
+    public boolean syncNote(Context context, long noteId) {
+        if (noteId <= 0) {
+            throw new IllegalArgumentException("Wrong note id:" + noteId);
+        }
+        if (!isLocalModified()) {
+            return true;
+        }
+        // 理论上，一旦数据改变，就应该更新LOCAL_MODIFIED和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.clear();
+        if (mNoteData.isLocalModified()
+                && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
+            return false;
+        }
+        return true;
+    }
+    // 定义公共方法syncNote，同步笔记数据到内容提供者
+    private class NoteData {
+        // 定义私有内部类NoteData
+        private long mTextDataId;
+        // 定义私有成员变量mTextDataId，类型为long
+        private ContentValues mTextDataValues;
+        // 定义私有成员变量mTextDataValues，类型为ContentValues
+        private long mCallDataId;
+        // 定义私有成员变量mCallDataId，类型为long
+        private ContentValues mCallDataValues;
+        // 定义私有成员变量mCallDataValues，类型为ContentValues
+        private static final String TAG = "NoteData";
+        // 定义私有静态常量TAG，值为"NoteData"，用于日志标记
+        public NoteData() {
+            mTextDataValues = new ContentValues();
+            mCallDataValues = new ContentValues();
+            mTextDataId = 0;
+            mCallDataId = 0;
+        }
+        // 定义NoteData类的构造函数，初始化成员变量
+        boolean isLocalModified() {
+            return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
+        }
+        // 定义私有方法isLocalModified，检查文本数据或通话数据是否在本地被修改过
+        void setTextDataId(long id) {
+            if(id <= 0) {
+                throw new IllegalArgumentException("Text data id should larger than 0");
+            }
+            mTextDataId = id;
+        }
+        // 定义私有方法setTextDataId，设置文本数据ID
+        void setCallDataId(long id) {
+            if (id <= 0) {
+                throw new IllegalArgumentException("Call data id should larger than 0");
+            }
+            mCallDataId = id;
+        }
+        void setCallData(String key, String value) {
+    mCallDataValues.put(key, value);
+    mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+    mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+}
+// 定义一个方法setCallData，接收两个字符串参数key和value，将它们存储到mCallDataValues中，并标记笔记为本地修改，记录当前时间。
+void setTextData(String key, String value) {
+    mTextDataValues.put(key, value);
+    mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+    mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+}
+// 定义一个方法setTextData，接收两个字符串参数key和value，将它们存储到mTextDataValues中，并标记笔记为本地修改，记录当前时间。
+Uri pushIntoContentResolver(Context context, long noteId) {
+    /**
+     * Check for safety
+     */
+    if (noteId <= 0) {
+        throw new IllegalArgumentException("Wrong note id:" + noteId);
+    }
+    // 定义一个方法pushIntoContentResolver，接收Context对象和笔记ID，首先检查笔记ID是否有效，如果无效则抛出异常。
+    ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+    ContentProviderOperation.Builder builder = null;
+    // 初始化一个ContentProviderOperation对象列表operationList和一个Builder对象。
+    if(mTextDataValues.size() > 0) {
+        mTextDataValues.put(DataColumns.NOTE_ID, noteId);
+        if (mTextDataId == 0) {
+            mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
+            Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                    mTextDataValues);
+            try {
+                setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Insert new text data fail with noteId" + noteId);
+                mTextDataValues.clear();
+                return null;
+            }
+        } else {
+            builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                    Notes.CONTENT_DATA_URI, mTextDataId));
+            builder.withValues(mTextDataValues);
+            operationList.add(builder.build());
+        }
+        mTextDataValues.clear();
+    }
+    // 如果文本数据值非空，则根据是否有文本数据ID来插入或更新文本数据，并添加到操作列表。
+    if(mCallDataValues.size() > 0) {
+        mCallDataValues.put(DataColumns.NOTE_ID, noteId);
+        if (mCallDataId == 0) {
+            mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
+            Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+                    mCallDataValues);
+            try {
+                setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Insert new call data fail with noteId" + noteId);
+                mCallDataValues.clear();
+                return null;
+            }
+        } else {
+            builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+                    Notes.CONTENT_DATA_URI, mCallDataId));
+            builder.withValues(mCallDataValues);
+            operationList.add(builder.build());
+        }
+        mCallDataValues.clear();
+    }
+    // 如果通话数据值非空，则根据是否有通话数据ID来插入或更新通话数据，并添加到操作列表。
+    if (operationList.size() > 0) {
+        try {
+            ContentProviderResult[] results = context.getContentResolver().applyBatch(
+                    Notes.AUTHORITY, operationList);
+            return (results == null || results.length == 0 || results[0] == null) ? null
+                    : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
+        } catch (RemoteException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+            return null;
+        } catch (OperationApplicationException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+            return null;
+        }
+    }
+    return null;
+}
+// 定义一个方法pushIntoContentResolver，用于将文本数据和通话数据的操作列表应用到内容提供者，并返回操作结果的Uri或null。

src/net/micode/notes/model/WorkingNote.java

@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ */
+// 版权所有 (c) 2010-2011，MiCode开源社区（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 
+ */
+// 根据Apache License, 版本2.0（“许可证”）授权；
+// 除非遵守许可证，否则不得使用此文件。
+// 您可以在以下网址获得许可证的副本：
+//
+//        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; // 声明该类属于net.micode.notes.model包。
+import android.appwidget.AppWidgetManager; // 导入Android的AppWidgetManager类
+import android.content.ContentUris; // 导入Android的ContentUris类
+import android.content.Context; // 导入Android的Context类
+import android.database.Cursor; // 导入Android的Cursor类
+import android.text.TextUtils; // 导入Android的TextUtils类
+import android.util.Log; // 导入Android的Log类
+import net.micode.notes.data.Notes; // 导入项目的Notes数据类
+import net.micode.notes.data.Notes.CallNote; // 导入项目的CallNote数据类
+import net.micode.notes.data.Notes.DataColumns; // 导入项目的DataColumns数据类
+import net.micode.notes.data.Notes.DataConstants; // 导入项目的DataConstants数据类
+import net.micode.notes.data.Notes.NoteColumns; // 导入项目的NoteColumns数据类
+import net.micode.notes.data.Notes.TextNote;  // 导入项目的TextNote数据类
+import net.micode.notes.tool.ResourceParser.NoteBgResources; // 导入项目的NoteBgResources工具类
+public class WorkingNote {
+    // 定义一个名为WorkingNote的公共类
+    // Note for the working note
+    private Note mNote;
+    // 定义一个私有成员变量mNote，类型为Note
+    // Note Id
+    private long mNoteId;
+    // 定义一个私有成员变量mNoteId，类型为long，表示笔记ID
+    // Note content
+    private String mContent;
+    // 定义一个私有成员变量mContent，类型为String，表示笔记内容
+    // Note mode
+    private int mMode;
+    // 定义一个私有成员变量mMode，类型为int，表示笔记模式
+    private long mAlertDate;
+    // 定义一个私有成员变量mAlertDate，类型为long，表示提醒日期
+    private long mModifiedDate;
+    // 定义一个私有成员变量mModifiedDate，类型为long，表示修改日期
+    private int mBgColorId;
+    // 定义一个私有成员变量mBgColorId，类型为int，表示背景颜色ID
+    private int mWidgetId;
+    // 定义一个私有成员变量mWidgetId，类型为int，表示小部件ID、
+    private int mWidgetType;
+    // 定义一个私有成员变量mWidgetType，类型为int，表示小部件类型
+    private long mFolderId;
+    // 定义一个私有成员变量mFolderId，类型为long，表示文件夹ID
+    private Context mContext;
+    // 定义一个私有成员变量mContext，类型为Context
+    private static final String TAG = "WorkingNote";
+    // 定义一个私有静态最终字符串TAG，值为"WorkingNote"，用于日志标记
+    private boolean mIsDeleted;
+    // 定义一个私有成员变量mIsDeleted，类型为boolean，表示笔记是否被删除
+    private NoteSettingChangedListener mNoteSettingStatusListener;
+    // 定义一个私有成员变量mNoteSettingStatusListener，类型为NoteSettingChangedListener
+    public static final String[] DATA_PROJECTION = new String[] {
+            DataColumns.ID,
+            DataColumns.CONTENT,
+            DataColumns.MIME_TYPE,
+            DataColumns.DATA1,
+            DataColumns.DATA2,
+            DataColumns.DATA3,
+            DataColumns.DATA4,
+    };
+    // 定义一个公共静态最终字符串数组DATA_PROJECTION，包含数据库查询所需的列名
+    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
+    };
+    // 定义一个公共静态最终字符串数组NOTE_PROJECTION，包含数据库查询所需的列名
+    private static final int DATA_ID_COLUMN = 0;
+    // 定义一个私有静态最终整数DATA_ID_COLUMN，值为0，表示DATA_PROJECTION数组中ID列的索引
+    private static final int DATA_CONTENT_COLUMN = 1;
+    // 定义一个私有静态最终整数DATA_CONTENT_COLUMN，值为1，表示DATA_PROJECTION数组中CONTENT列的索引
+    private static final int DATA_MIME_TYPE_COLUMN = 2;
+    // 定义一个私有静态最终整数DATA_MIME_TYPE_COLUMN，值为2，表示DATA_PROJECTION数组中MIME_TYPE列的索引
+    private static final int DATA_MODE_COLUMN = 3;
+    // 定义一个私有静态最终整数DATA_MODE_COLUMN，值为3，表示DATA_PROJECTION数组中MODE列的索引
+    private static final int NOTE_PARENT_ID_COLUMN = 0;
+    // 定义一个私有静态最终整数NOTE_PARENT_ID_COLUMN，值为0，表示NOTE_PROJECTION数组中PARENT_ID列的索引
+    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
+    // 定义一个私有静态最终整数NOTE_ALERTED_DATE_COLUMN，值为1，表示NOTE_PROJECTION数组中ALERTED_DATE列的索引
+    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
+    // 定义一个私有静态最终整数NOTE_BG_COLOR_ID_COLUMN，值为2，表示NOTE_PROJECTION数组中BG_COLOR_ID列的索引
+    private static final int NOTE_WIDGET_ID_COLUMN = 3;
+    // 定义一个私有静态最终整数NOTE_WIDGET_ID_COLUMN，值为3，表示NOTE_PROJECTION数组中WIDGET_ID列的索引
+    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
+    // 定义一个私有静态最终整数NOTE_WIDGET_TYPE_COLUMN，值为4，表示NOTE_PROJECTION数组中WIDGET_TYPE列的索引
+    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
+    // 定义一个私有静态最终整数NOTE_MODIFIED_DATE_COLUMN，值为5，表示NOTE_PROJECTION数组中MODIFIED_DATE列的索引
+    // New note construct
+    private WorkingNote(Context context, long folderId) {
+        mContext = context;
+        mAlertDate = 0;
+        mModifiedDate = System.currentTimeMillis();
+        mFolderId = folderId;
+        mNote = new Note();
+        mNoteId = 0;
+        mIsDeleted = false;
+        mMode = 0;
+        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+    }
+    // 定义一个私有构造函数，用于创建一个新的WorkingNote对象
+    // Existing note construct
+    private WorkingNote(Context context, long noteId, long folderId) {
+        mContext = context;
+        mNoteId = noteId;
+        mFolderId = folderId;
+        mIsDeleted = false;
+        mNote = new Note();
+        loadNote();
+    }
+    // 定义一个私有构造函数，用于根据笔记ID和文件夹ID创建一个已存在的WorkingNote对象
+    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);
+                mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
+                mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
+                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, "No note with id:" + mNoteId);
+            throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
+        }
+        loadNoteData();
+    }
+    // 定义一个私有方法loadNote，用于从数据库加载笔记信息
+  private void loadNoteData() {
+    // 定义一个私有方法loadNoteData，用于从数据库加载笔记数据
+    Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
+            DataColumns.NOTE_ID + "=?", new String[] {
+                String.valueOf(mNoteId)
+            }, null); 
+    // 执行查询操作，获取与当前笔记ID关联的数据
+    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, "Wrong note type with type:" + type);
+                    // 记录日志，表示遇到未知的笔记类型
+                }
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+    } else {
+        Log.e(TAG, "No data with id:" + mNoteId);
+        // 记录错误日志，表示没有找到与笔记ID关联的数据
+        throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
+        // 抛出异常，表示无法找到笔记数据
+    }
+}
+public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
+        int widgetType, int defaultBgColorId) {
+    // 定义一个公共静态方法createEmptyNote，用于创建一个空的WorkingNote对象
+    WorkingNote note = new WorkingNote(context, folderId);
+    note.setBgColorId(defaultBgColorId);
+    note.setWidgetId(widgetId);
+    note.setWidgetType(widgetType);
+    return note;
+    // 返回新创建的空WorkingNote对象
+}
+public static WorkingNote load(Context context, long id) {
+    // 定义一个公共静态方法load，用于根据ID加载一个WorkingNote对象
+    return new WorkingNote(context, id, 0);
+    // 返回新加载的WorkingNote对象
+}
+public synchronized boolean saveNote() {
+    // 定义一个公共同步方法saveNote，用于保存笔记
+    if (isWorthSaving()) {
+        if (!existInDatabase()) {
+            if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
+                Log.e(TAG, "Create new note fail with id:" + mNoteId);
+                return false;
+            }
+        }
+        mNote.syncNote(mContext, mNoteId);
+        // 如果存在与该笔记关联的小部件，则更新小部件内容
+        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+                && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
+                && mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onWidgetChanged();
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+public boolean existInDatabase() {
+    // 定义一个公共方法existInDatabase，用于检查笔记是否存在于数据库中
+    return mNoteId > 0;
+    // 返回笔记ID是否大于0，表示笔记是否存在于数据库中
+}
+private boolean isWorthSaving() {
+    // 定义一个私有方法isWorthSaving，用于判断笔记是否值得保存
+    if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
+            || (existInDatabase() && !mNote.isLocalModified())) {
+        return false;
+    } else {
+        return true;
+    }
+}
+public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
+    // 定义一个公共方法setOnSettingStatusChangedListener，用于设置笔记设置状态变化的监听器
+    mNoteSettingStatusListener = l;
+}
+public void setAlertDate(long date, boolean set) {
+    // 定义一个公共方法setAlertDate，用于设置提醒日期
+    if (date != mAlertDate) {
+        mAlertDate = date;
+        mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
+    }
+    if (mNoteSettingStatusListener != null) {
+        mNoteSettingStatusListener.onClockAlertChanged(date, set);
+    }
+}
+public void markDeleted(boolean mark) {
+    // 定义一个公共方法markDeleted，用于标记笔记为已删除
+    mIsDeleted = mark;
+    if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+            && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
+        mNoteSettingStatusListener.onWidgetChanged();
+    }
+}
+public void setBgColorId(int id) {
+    // 定义一个公共方法setBgColorId，用于设置背景颜色ID
+    if (id != mBgColorId) {
+        mBgColorId = id;
+        if (mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onBackgroundColorChanged();
+        }
+        mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
+    }
+} 
+public void setCheckListMode(int mode) {
+    // 定义一个公共方法setCheckListMode，用于设置检查列表模式
+    if (mMode != mode) {
+        if (mNoteSettingStatusListener != null) {
+            mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
+        }
+        mMode = mode;
+        mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
+    }
+}
+public void setWidgetType(int type) {
+    // 定义一个公共方法setWidgetType，用于设置小部件类型
+    if (type != mWidgetType) {
+        mWidgetType = type;
+        mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
+    }
+}
+public void setWidgetId(int id) {
+    // 定义一个公共方法setWidgetId，用于设置小部件ID
+    if (id != mWidgetId) {
+        mWidgetId = id;
+        mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
+    }
+}
+public void setWorkingText(String text) {
+    // 定义一个公共方法setWorkingText，用于设置工作文本
+    if (!TextUtils.equals(mContent, text)) {
+        mContent = text;
+        mNote.setTextData(DataColumns.CONTENT, mContent);
+    }
+}
+public void convertToCallNote(String phoneNumber, long callDate) {
+    // 定义一个公共方法convertToCallNote，用于将笔记转换为通话笔记
+    mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
+    mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
+    mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
+}
+public boolean hasClockAlert() {
+    // 定义一个公共方法hasClockAlert，用于检查笔记是否有时钟提醒
+    return (mAlertDate > 0 ? true : false);
+}
+public String getContent() {
+    // 定义一个公共方法getContent，用于获取笔记内容
+    return mContent;
+}
+public long getAlertDate() {
+    // 定义一个公共方法getAlertDate，用于获取提醒日期
+    return mAlertDate;
+}
+public long getModifiedDate() {
+    // 定义一个公共方法getModifiedDate，用于获取修改日期
+    return mModifiedDate;
+}
+public int getBgColorResId() {
+    // 定义一个公共方法getBgColorResId，用于获取背景颜色资源ID
+    return NoteBgResources.getNoteBgResource(mBgColorId);
+}
+public int getBgColorId() {
+    // 定义一个公共方法getBgColorId，用于获取背景颜色ID
+    return mBgColorId;
+}
+public int getTitleBgResId() {
+    // 定义一个公共方法getTitleBgResId，用于获取标题背景资源ID
+    return NoteBgResources.getNoteTitleBgResource(mBgColorId);
+}
+public int getCheckListMode() {
+    // 定义一个公共方法getCheckListMode，用于获取检查列表模式
+    return mMode;
+}
+public long getNoteId() {
+    // 定义一个公共方法getNoteId，用于获取笔记ID
+    return mNoteId;
+}
+public long getFolderId() {
+    // 定义一个公共方法getFolderId，用于获取文件夹ID
+    return mFolderId;
+}
+public int getWidgetId() {
+    // 定义一个公共方法getWidgetId，用于获取小部件ID
+    return mWidgetId;
+}
+public int getWidgetType() {
+    // 定义一个公共方法getWidgetType，用于获取小部件类型
+    return mWidgetType;
+}
+public interface NoteSettingChangedListener {
+    // 定义一个公共接口NoteSettingChangedListener，用于监听笔记设置变化
+    /**
+     * Called when the background color of current note has just changed
+     */
+    void onBackgroundColorChanged();
+    /**
+/**
+ * Called when user set clock
+ */
+void onClockAlertChanged(long date, boolean set);
+// 当用户设置时钟提醒时调用
+// 参数date表示设置的日期，set表示是否设置了提醒
+/**
+ * Call when user create note from widget
+ */
+void onWidgetChanged();
+// 当用户从widget创建笔记时调用
+/**
+ * Call when switch between check list mode and normal mode
+ * @param oldMode is previous mode before change
+ * @param newMode is new mode
+ */
+void onCheckListModeChanged(int oldMode, int newMode);
+// 当用户在检查列表模式和普通模式之间切换时调用
+// 参数oldMode表示之前的模式，newMode表示新的模式

src/net/micode/notes/widget/NoteWidgetProvider.java

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ */
+// 版权所有 (c) 2010-2011，MiCode开源社区（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 
+ */
+// 根据Apache License, 版本2.0（“许可证”）授权；
+// 除非遵守许可证，否则不得使用此文件。
+// 您可以在以下网址获得许可证的副本：
+//
+//        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.widget;
+// 声明该类属于net.micode.notes.widget包。
+import android.app.PendingIntent;
+// 导入PendingIntent类
+import android.appwidget.AppWidgetManager;
+// 导入AppWidgetManager类
+import android.appwidget.AppWidgetProvider;
+// 导入AppWidgetProvider类
+import android.content.ContentValues;
+// 导入ContentValues类
+import android.content.Context;
+// 导入Context类
+import android.content.Intent;
+// 导入Intent类
+import android.database.Cursor;
+// 导入Cursor类
+import android.util.Log;
+// 导入Log类
+import android.widget.RemoteViews;
+// 导入RemoteViews类
+import net.micode.notes.R;
+// 导入项目资源类
+import net.micode.notes.data.Notes;
+// 导入Notes数据类
+import net.micode.notes.data.Notes.NoteColumns;
+// 导入NoteColumns数据类
+import net.micode.notes.tool.ResourceParser;
+// 导入ResourceParser工具类
+import net.micode.notes.ui.NoteEditActivity;
+// 导入NoteEditActivity界面类
+import net.micode.notes.ui.NotesListActivity;
+// 导入NotesListActivity界面类
+public abstract class NoteWidgetProvider extends AppWidgetProvider {
+    // 定义一个抽象的NoteWidgetProvider类，继承自AppWidgetProvider
+    public static final String [] PROJECTION = new String [] {
+        NoteColumns.ID,
+        NoteColumns.BG_COLOR_ID,
+        NoteColumns.SNIPPET
+    };
+    // 定义一个公共静态最终字符串数组PROJECTION，包含数据库查询所需的列名
+    public static final int COLUMN_ID           = 0;
+    public static final int COLUMN_BG_COLOR_ID  = 1;
+    public static final int COLUMN_SNIPPET      = 2;
+    // 定义公共静态最终整数COLUMN_ID、COLUMN_BG_COLOR_ID和COLUMN_SNIPPET，表示PROJECTION数组中对应列的索引
+    private static final String TAG = "NoteWidgetProvider";
+    // 定义一个私有静态最终字符串TAG，值为"NoteWidgetProvider"，用于日志标记
+    @Override
+    public void onDeleted(Context context, int[] appWidgetIds) {
+        // 重写onDeleted方法，接收Context对象和appWidgetIds数组作为参数
+        ContentValues values = new ContentValues();
+        values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
+        // 创建ContentValues对象values，并设置WIDGET_ID列为无效的AppWidget ID
+        for (int i = 0; i < appWidgetIds.length; i++) {
+            context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
+                    values,
+                    NoteColumns.WIDGET_ID + "=?",
+                    new String[] { String.valueOf(appWidgetIds[i])});
+            // 对每个appWidgetIds，更新Notes.CONTENT_NOTE_URI对应的数据，将WIDGET_ID列设置为无效的AppWidget ID
+        }
+    }
+    private Cursor getNoteWidgetInfo(Context context, int widgetId) {
+        // 定义一个私有方法getNoteWidgetInfo，接收Context对象和widgetId作为参数，返回Cursor对象
+        return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                PROJECTION,
+                NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
+                new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
+                null);
+        // 执行查询操作，返回与widgetId关联的笔记信息
+    }
+    protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 定义一个受保护的方法update，接收Context对象、AppWidgetManager对象和appWidgetIds数组作为参数
+        update(context, appWidgetManager, appWidgetIds, false);
+        // 调用另一个update方法，传入false作为privacyMode参数
+    }
+    private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
+            boolean privacyMode) {
+        // 定义一个私有方法update，接收Context对象、AppWidgetManager对象、appWidgetIds数组和privacyMode布尔值作为参数
+        for (int i = 0; i < appWidgetIds.length; i++) {
+            // 遍历appWidgetIds数组
+            if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
+                // 如果appWidgetIds[i]有效
+                int bgId = ResourceParser.getDefaultBgId(context);
+                // 获取默认背景ID
+                String snippet = "";
+                // 初始化字符串snippet
+                Intent intent = new Intent(context, NoteEditActivity.class);
+                // 创建Intent对象，用于启动NoteEditActivity
+                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
+                // 设置Intent标志为FLAG_ACTIVITY_SINGLE_TOP
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
+                // 将widget ID作为额外数据传递给NoteEditActivity
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
+                // 将widget类型作为额外数据传递给NoteEditActivity
+
+                Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
+                // 获取与appWidgetIds[i]关联的笔记信息
+                if (c != null && c.moveToFirst()) {
+                    // 如果查询结果不为空且可以移动到第一条记录
+                    if (c.getCount() > 1) {
+                        // 如果查询结果有多条记录
+                        Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
+                        // 记录错误日志
+                        c.close();
+                        // 关闭Cursor
+                        return;
+                    }
+                    snippet = c.getString(COLUMN_SNIPPET);
+                    // 获取snippet信息
+                    bgId = c.getInt(COLUMN_BG_COLOR_ID);
+                    // 获取背景ID
+                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
+                    // 将ID作为额外数据传递给NoteEditActivity
+                    intent.setAction(Intent.ACTION_VIEW);
+                    // 设置Intent动作为ACTION_VIEW
+                } else {
+                    // 如果查询结果为空
+                    snippet = context.getResources().getString(R.string.widget_havenot_content);
+                    // 设置snippet为默认字符串
+                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+                    // 设置Intent动作为ACTION_INSERT_OR_EDIT
+                }
+                if (c != null) {
+                    c.close();
+                }
+                // 关闭Cursor
+                RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
+                // 创建RemoteViews对象，用于更新AppWidget布局
+                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
+                // 设置背景图片资源
+                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
+                // 将背景ID作为额外数据传递给NoteEditActivity
+                /**
+                 * Generate the pending intent to start host for the widget
+                 */
+                // 生成PendingIntent，用于启动AppWidget的宿主Activity
+                PendingIntent pendingIntent = null;
+                if (privacyMode) {
+                    // 如果处于隐私模式
+                    rv.setTextViewText(R.id.widget_text,
+                            context.getString(R.string.widget_under_visit_mode));
+                    // 设置文本内容为隐私模式下的提示文本
+                    pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
+                            context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
+                    // 创建PendingIntent，用于启动NotesListActivity
+                } else {
+                    // 如果不处于隐私模式
+                    rv.setTextViewText(R.id.widget_text, snippet);
+                    // 设置文本内容为snippet
+                    pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
+                            PendingIntent.FLAG_UPDATE_CURRENT);
+                    // 创建PendingIntent，用于启动NoteEditActivity
+                }
+                rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
+                // 设置RemoteViews的点击事件，关联PendingIntent
+                appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
+                // 更新AppWidget
+            }
+        }
+    }
+protected abstract int getBgResourceId(int bgId);
+// 这是一个抽象方法，需要子类实现。该方法根据传入的背景ID（bgId）返回一个对应的背景资源ID。
+protected abstract int getLayoutId();
+// 这是一个抽象方法，需要子类实现。该方法返回一个整数，表示AppWidget使用的布局资源ID。
+protected abstract int getWidgetType();
+// 这是一个抽象方法，需要子类实现。该方法返回一个整数，表示AppWidget的类型。

src/net/micode/notes/widget/NoteWidgetProvider_2x.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ */
+// 版权所有 (c) 2010-2011，MiCode开源社区（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 
+ */
+// 根据Apache License, 版本2.0（“许可证”）授权；
+// 除非遵守许可证，否则不得使用此文件。
+// 您可以在以下网址获得许可证的副本：
+//
+//        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.widget;
+// 声明该类属于net.micode.notes.widget包。
+import android.appwidget.AppWidgetManager;
+// 导入AppWidgetManager类
+import android.content.Context;
+// 导入Context类
+import net.micode.notes.R;
+// 导入项目资源类
+import net.micode.notes.data.Notes;
+// 导入Notes数据类
+import net.micode.notes.tool.ResourceParser;
+// 导入ResourceParser工具类
+public class NoteWidgetProvider_2x extends NoteWidgetProvider {
+    // 定义一个名为NoteWidgetProvider_2x的公共类，继承自NoteWidgetProvider
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 重写onUpdate方法，接收Context对象、AppWidgetManager对象和appWidgetIds数组作为参数
+        super.update(context, appWidgetManager, appWidgetIds);
+        // 调用父类的update方法
+    }
+    @Override
+    protected int getLayoutId() {
+        // 重写getLayoutId方法，返回布局资源ID
+        return R.layout.widget_2x;
+        // 返回2x布局资源ID
+    }
+    @Override
+    protected int getBgResourceId(int bgId) {
+        // 重写getBgResourceId方法，接收一个整数bgId作为参数，返回背景资源ID
+        return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
+        // 根据bgId返回2x小部件的背景资源ID
+    }
+    @Override
+    protected int getWidgetType() {
+        // 重写getWidgetType方法，返回小部件类型
+        return Notes.TYPE_WIDGET_2X;
+        // 返回2x小部件类型
+    }
+}
+// 结束NoteWidgetProvider_2x类的定义

src/net/micode/notes/widget/NoteWidgetProvider_4x.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ */
+// 版权所有 (c) 2010-2011，MiCode开源社区（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 
+ */
+// 根据Apache License, 版本2.0（“许可证”）授权；
+// 除非遵守许可证，否则不得使用此文件。
+// 您可以在以下网址获得许可证的副本：
+//
+//        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.widget;
+// 声明该类属于net.micode.notes.widget包。
+import android.appwidget.AppWidgetManager;
+// 导入Android的AppWidgetManager类
+import android.content.Context;
+// 导入Android的Context类
+import net.micode.notes.R;
+// 导入项目的R资源类
+import net.micode.notes.data.Notes;
+// 导入项目的Notes数据类
+import net.micode.notes.tool.ResourceParser;
+// 导入项目的ResourceParser工具类
+public class NoteWidgetProvider_4x extends NoteWidgetProvider {
+    // 定义一个名为NoteWidgetProvider_4x的公共类，继承自NoteWidgetProvider
+    @Override
+    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 重写onUpdate方法，接收Context对象、AppWidgetManager对象和appWidgetIds数组作为参数
+        super.update(context, appWidgetManager, appWidgetIds);
+        // 调用父类的update方法
+    }
+    @Override
+    protected int getLayoutId() {
+        // 重写getLayoutId方法，返回布局资源ID
+        return R.layout.widget_4x;
+        // 返回4x布局资源ID
+    }
+    @Override
+    protected int getBgResourceId(int bgId) {
+        // 重写getBgResourceId方法，接收一个整数bgId作为参数，返回背景资源ID
+        return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
+        // 根据bgId返回4x小部件的背景资源ID
+    }
+    @Override
+    protected int getWidgetType() {
+        // 重写getWidgetType方法，返回小部件类型
+        return Notes.TYPE_WIDGET_4X;
+        // 返回4x小部件类型
+    }
+}
+// 结束NoteWidgetProvider_4x类的定义

tool/BackupUtils.java

@@ -0,0 +1,151 @@
+/*
+ * 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.tool;
+
+// 导入必要的Android框架类和自定义的Notes数据类
+import android.content.Context;
+import android.database.Cursor;
+import android.os.Environment;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.util.Log;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintStream;
+
+// 导入自定义的Notes数据类
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+
+// BackupUtils类使用单例模式，确保整个应用中只有一个实例
+public class BackupUtils {
+    private static final String TAG = "BackupUtils";
+    private static BackupUtils sInstance;
+
+    public static synchronized BackupUtils getInstance(Context context) {
+        if (sInstance == null) {
+            sInstance = new BackupUtils(context);
+        }
+        return sInstance;
+    }
+
+    // 定义备份或恢复过程中的状态常量
+    public static final int STATE_SD_CARD_UNMOUONTED = 0;
+    public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
+    public static final int STATE_DATA_DESTROIED = 2;
+    public static final int STATE_SYSTEM_ERROR = 3;
+    public static final int STATE_SUCCESS = 4;
+
+    private TextExport mTextExport;
+
+    private BackupUtils(Context context) {
+        mTextExport = new TextExport(context);
+    }
+
+    // 检查外部存储是否可用
+    private static boolean externalStorageAvailable() {
+        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
+    }
+
+    // 导出数据到文本文件
+    public int exportToText() {
+        return mTextExport.exportToText();
+    }
+
+    // 获取导出的文本文件名
+    public String getExportedTextFileName() {
+        return mTextExport.mFileName;
+    }
+
+    // 获取导出的文本文件目录
+    public String getExportedTextFileDir() {
+        return mTextExport.mFileDirectory;
+    }
+
+    // TextExport内部类，负责实际的文本导出逻辑
+    private static class TextExport {
+        // 定义查询数据库时使用的列投影
+        private static final String[] NOTE_PROJECTION = {
+                NoteColumns.ID,
+                NoteColumns.MODIFIED_DATE,
+                NoteColumns.SNIPPET,
+                NoteColumns.TYPE
+        };
+        // ...（其他列投影定义）
+
+        // 定义文本格式化字符串数组
+        private final String[] TEXT_FORMAT;
+        // ...（其他静态常量定义）
+
+        private Context mContext;
+        private String mFileName;
+        private String mFileDirectory;
+
+        public TextExport(Context context) {
+            TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
+            // 初始化成员变量
+        }
+
+        // 导出文件夹到文本
+        private void exportFolderToText(String folderId, PrintStream ps) {
+            // 查询属于该文件夹的笔记，并导出
+        }
+
+        // 导出笔记到文本
+        private void exportNoteToText(String noteId, PrintStream ps) {
+            // 查询属于该笔记的数据，并导出
+        }
+
+        // 导出数据到文本文件
+        public int exportToText() {
+            if (!externalStorageAvailable()) {
+                // 如果外部存储不可用，返回错误状态
+                return STATE_SD_CARD_UNMOUONTED;
+            }
+
+            PrintStream ps = getExportToTextPrintStream();
+            if (ps == null) {
+                // 如果无法获取PrintStream，返回错误状态
+                return STATE_SYSTEM_ERROR;
+            }
+
+            // 查询并导出文件夹和笔记数据
+            Cursor folderCursor = mContext.getContentResolver().query(
+                    // ...（查询逻辑）
+
+                    Cursor noteCursor = mContext.getContentResolver().query(
+                            // ...（查询逻辑）
+
+                            ps.close();
+            // 关闭PrintStream并返回成功状态
+            return STATE_SUCCESS;
+        }
+
+        // 获取PrintStream指向的文件
+        private PrintStream getExportToTextPrintStream() {
+            // 生成文件路径并创建文件
+        }
+
+        // 生成文本文件以存储导入的数据
+        private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+            // 生成文件路径并创建文件
+        }
+    }
+}

tool/DataUtils.java

@@ -0,0 +1,408 @@
+/*
+ * 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.tool;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.OperationApplicationException;
+import android.database.Cursor;
+import android.os.RemoteException;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class DataUtils {
+    public static final String TAG = "DataUtils";
+
+    /**
+     * 批量删除笔记。
+     *
+     * @param resolver ContentResolver实例，用于执行删除操作。
+     * @param ids 要删除的笔记ID集合。
+     * @return 如果成功删除所有笔记返回true，否则返回false。
+     */
+    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+        // 检查传入的ID集合是否为null或为空
+        if (ids == null || ids.size() == 0) {
+            Log.d(TAG, "the ids is null or empty");
+            return true;
+        }
+
+        // 创建操作列表
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        for (long id : ids) {
+            // 不允许删除系统文件夹根目录
+            if (id == Notes.ID_ROOT_FOLDER) {
+                Log.e(TAG, "Don't delete system folder root");
+                continue;
+            }
+            // 构建删除操作
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            operationList.add(builder.build());
+        }
+
+        try {
+            // 执行批量操作
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 检查操作是否成功
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+                return false;
+            }
+            return true;
+        } catch (RemoteException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        return false;
+    }
+
+    /**
+     * 将笔记移动到指定文件夹。
+     *
+     * @param resolver ContentResolver实例，用于执行更新操作。
+     * @param id 要移动的笔记ID。
+     * @param srcFolderId 笔记当前所在文件夹ID。
+     * @param desFolderId 笔记要移动到的目标文件夹ID。
+     */
+    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+        // 创建更新操作的值集
+        ContentValues values = new ContentValues();
+        // 设置新的父文件夹ID
+        values.put(NoteColumns.PARENT_ID, desFolderId);
+        // 记录原始父文件夹ID
+        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
+        // 标记笔记为已修改
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        // 执行更新操作
+        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
+    }
+
+    /**
+     * 批量将笔记移动到指定文件夹。
+     *
+     * @param resolver ContentResolver实例，用于执行批量更新操作。
+     * @param ids 要移动的笔记ID集合。
+     * @param folderId 目标文件夹ID。
+     * @return 如果成功移动所有笔记返回true，否则返回false。
+     */
+    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids, long folderId) {
+        // 检查传入的ID集合是否为null
+        if (ids == null) {
+            Log.d(TAG, "the ids is null");
+            return true;
+        }
+
+        // 创建操作列表
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        for (long id : ids) {
+            // 构建更新操作
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            // 设置新的父文件夹ID
+            builder.withValue(NoteColumns.PARENT_ID, folderId);
+            // 标记笔记为已修改
+            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
+            operationList.add(builder.build());
+        }
+
+        try {
+            // 执行批量操作
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 检查操作是否成功
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "move notes failed, ids:" + ids.toString());
+                return false;
+            }
+            return true;
+        } catch (RemoteException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        return false;
+    }
+
+    /**
+     * 获取用户文件夹数量（排除系统文件夹）。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @return 用户文件夹的数量。
+     */
+    public static int getUserFolderCount(ContentResolver resolver) {
+        // 执行查询操作，计算非系统文件夹的数量
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[] { "COUNT(*)" },
+                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
+                new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
+                null);
+
+        int count = 0;
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                try {
+                    count = cursor.getInt(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "get folder count failed:" + e.toString());
+                } finally {
+                    cursor.close();
+                }
+            }
+        }
+        return count;
+    }
+
+    /**
+     * 检查指定类型的笔记是否在笔记数据库中可见。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @param noteId 笔记ID。
+     * @param type 笔记类型。
+     * @return 如果笔记存在且可见返回true，否则返回false。
+     */
+    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+        // 执行查询操作，检查指定类型的笔记是否存在且不在回收站中
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null,
+                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
+                new String [] {String.valueOf(type)},
+                null);
+
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    /**
+     * 检查笔记是否存在于笔记数据库中。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @param noteId 笔记ID。
+     * @return 如果笔记存在返回true，否则返回false。
+     */
+    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+        // 执行查询操作，检查笔记是否存在
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null, null, null, null);
+
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    /**
+     * 检查数据是否存在于数据数据库中。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @param dataId 数据ID。
+     * @return 如果数据存在返回true，否则返回false。
+     */
+    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+        // 执行查询操作，检查数据是否存在
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
+                null, null, null, null);
+
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    /**
+     * 检查文件夹名称是否在笔记数据库中可见。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @param name 文件夹名称。
+     * @return 如果文件夹名称存在返回true，否则返回false。
+     */
+    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
+        // 执行查询操作，检查文件夹名称是否存在于非回收站的文件夹中
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
+                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
+                        " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
+                        " AND " + NoteColumns.SNIPPET + "=?",
+                new String[] { name }, null);
+        boolean exist = false;
+        if (cursor != null) {
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            cursor.close();
+        }
+        return exist;
+    }
+
+    /**
+     * 获取指定文件夹中所有笔记的小部件属性。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @param folderId 文件夹ID。
+     * @return 包含小部件属性的HashSet。
+     */
+    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+        // 执行查询操作，获取文件夹中笔记的小部件属性
+        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
+                NoteColumns.PARENT_ID + "=?",
+                new String[] { String.valueOf(folderId) },
+                null);
+
+        HashSet<AppWidgetAttribute> set = null;
+        if (c != null) {
+            if (c.moveToFirst()) {
+                set = new HashSet<AppWidgetAttribute>();
+                do {
+                    try {
+                        AppWidgetAttribute widget = new AppWidgetAttribute();
+                        widget.widgetId = c.getInt(0);
+                        widget.widgetType = c.getInt(1);
+                        set.add(widget);
+                    } catch (IndexOutOfBoundsException e) {
+                        Log.e(TAG, e.toString());
+                    }
+                } while (c.moveToNext());
+            }
+            c.close();
+        }
+        return set;
+    }
+
+    /**
+     * 通过笔记ID获取电话号码。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @param noteId 笔记ID。
+     * @return 电话号码字符串。
+     */
+    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+        // 执行查询操作，获取与笔记ID关联的电话号码
+        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                new String [] { CallNote.PHONE_NUMBER },
+                CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
+                new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
+                null);
+
+        if (cursor != null && cursor.moveToFirst()) {
+            try {
+                return cursor.getString(0);
+            } catch (IndexOutOfBoundsException e) {
+                Log.e(TAG, "Get call number fails " + e.toString());
+            } finally {
+                cursor.close();
+            }
+        }
+        return "";
+    }
+
+    /**
+     * 通过电话号码和通话日期获取笔记ID。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @param phoneNumber 电话号码。
+     * @param callDate 通话日期。
+     * @return 笔记ID。
+     */
+    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+        // 执行查询操作，获取与电话号码和通话日期关联的笔记ID
+        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                new String [] { CallNote.NOTE_ID },
+                CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)",
+                new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
+                null);
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                try {
+                    return cursor.getLong(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "Get call note id fails " + e.toString());
+                }
+            }
+            cursor.close();
+        }
+        return 0;
+    }
+
+    /**
+     * 通过笔记ID获取笔记摘要。
+     *
+     * @param resolver ContentResolver实例，用于执行查询操作。
+     * @param noteId 笔记ID。
+     * @return 笔记摘要字符串。
+     */
+    public static String getSnippetById(ContentResolver resolver, long noteId) {
+        // 执行查询操作，获取笔记摘要
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String [] { NoteColumns.SNIPPET },
+                NoteColumns.ID + "=?",
+                new String [] { String.valueOf(noteId)},
+                null);
+
+        if (cursor != null) {
+            String snippet = "";
+            if (cursor.moveToFirst()) {
+                snippet = cursor.getString(0);
+            }
+            cursor.close();
+            return snippet;
+        }
+        throw new IllegalArgumentException("Note is not found with id: " + noteId);
+    }
+
+    /**
+     * 格式化笔记摘要。
+     *
+     * @param snippet 笔记摘要。
+     * @return 格式化后的笔记摘要。
+     */
+    public static String getFormattedSnippet(String snippet) {
+        // 去除摘要两端的空白字符，并去除换行符
+        if (snippet != null) {
+            snippet = snippet.trim();
+            int index = snippet.indexOf('\n');
+            if (index != -1) {
+                snippet = snippet.substring(0, index);
+            }
+        }
+        return snippet;
+    }
+}

tool/GTaskStringUtils.java

@@ -0,0 +1,152 @@
+/*
+ * 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.tool;
+
+public class GTaskStringUtils {
+
+    // JSON键值，用于标识动作的唯一ID
+    public final static String GTASK_JSON_ACTION_ID = "action_id";
+
+    // JSON键值，用于标识动作列表
+    public final static String GTASK_JSON_ACTION_LIST = "action_list";
+
+    // JSON键值，用于标识动作类型
+    public final static String GTASK_JSON_ACTION_TYPE = "action_type";
+
+    // JSON键值，创建任务的动作类型
+    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
+
+    // JSON键值，获取所有任务的动作类型
+    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
+
+    // JSON键值，移动任务的动作类型
+    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
+
+    // JSON键值，更新任务的动作类型
+    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
+
+    // JSON键值，标识创建者的ID
+    public final static String GTASK_JSON_CREATOR_ID = "creator_id";
+
+    // JSON键值，子实体标识
+    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
+
+    // JSON键值，客户端版本标识
+    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
+
+    // JSON键值，标识任务是否已完成
+    public final static String GTASK_JSON_COMPLETED = "completed";
+
+    // JSON键值，当前列表的ID
+    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
+
+    // JSON键值，默认列表的ID
+    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
+
+    // JSON键值，标识任务是否已被删除
+    public final static String GTASK_JSON_DELETED = "deleted";
+
+    // JSON键值，目标列表标识
+    public final static String GTASK_JSON_DEST_LIST = "dest_list";
+
+    // JSON键值，目标父项标识
+    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
+
+    // JSON键值，目标父项类型标识
+    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
+
+    // JSON键值，实体变化标识
+    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
+
+    // JSON键值，实体类型标识，包括任务和分组
+    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
+
+    // JSON键值，获取已删除任务的标识
+    public final static String GTASK_JSON_GET_DELETED = "get_deleted";
+
+    // JSON键值，通用的ID标识
+    public final static String GTASK_JSON_ID = "id";
+
+    // JSON键值，索引标识
+    public final static String GTASK_JSON_INDEX = "index";
+
+    // JSON键值，最后修改时间标识
+    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
+
+    // JSON键值，最新同步点标识
+    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
+
+    // JSON键值，列表的ID标识
+    public final static String GTASK_JSON_LIST_ID = "list_id";
+
+    // JSON键值，列表标识
+    public final static String GTASK_JSON_LISTS = "lists";
+
+    // JSON键值，名称标识
+    public final static String GTASK_JSON_NAME = "name";
+
+    // JSON键值，新的ID标识
+    public final static String GTASK_JSON_NEW_ID = "new_id";
+
+    // JSON键值，注释或笔记标识
+    public final static String GTASK_JSON_NOTES = "notes";
+
+    // JSON键值，父项的ID标识
+    public final static String GTASK_JSON_PARENT_ID = "parent_id";
+
+    // JSON键值，前一个同级项的ID标识
+    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
+
+    // JSON键值，结果标识
+    public final static String GTASK_JSON_RESULTS = "results";
+
+    // JSON键值，源列表标识
+    public final static String GTASK_JSON_SOURCE_LIST = "source_list";
+
+    // JSON键值，任务标识
+    public final static String GTASK_JSON_TASKS = "tasks";
+
+    // JSON键值，类型标识
+    public final static String GTASK_JSON_TYPE = "type";
+
+    // JSON键值，用户标识
+    public final static String GTASK_JSON_USER = "user";
+
+    // 文件夹前缀标识，用于MIUI笔记
+    public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
+
+    // 默认文件夹名称
+    public final static String FOLDER_DEFAULT = "Default";
+
+    // 通话笔记文件夹名称
+    public final static String FOLDER_CALL_NOTE = "Call_Note";
+
+    // 元数据文件夹名称
+    public final static String FOLDER_META = "METADATA";
+
+    // 元数据头标识，表示Google任务ID
+    public final static String META_HEAD_GTASK_ID = "meta_gid";
+
+    // 元数据头标识，表示笔记
+    public final static String META_HEAD_NOTE = "meta_note";
+
+    // 元数据头标识，表示数据
+    public final static String META_HEAD_DATA = "meta_data";
+
+    // 元数据笔记名称，提示不要更新和删除
+    public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
+}

tool/ResourceParser.java

@@ -0,0 +1,204 @@
+/*
+ * 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.tool;
+
+// 导入Android框架中用于访问偏好设置和资源的类
+import android.content.Context;
+import android.preference.PreferenceManager;
+
+// 导入资源文件和偏好设置活动类
+import net.micode.notes.R;
+import net.micode.notes.ui.NotesPreferenceActivity;
+
+// ResourceParser类用于解析和管理应用中的资源
+public class ResourceParser {
+
+    // 定义颜色资源的静态常量
+    public static final int YELLOW            = 0;
+    public static final int BLUE              = 1;
+    public static final int WHITE             = 2;
+    public static final int GREEN             = 3;
+    public static final int RED               = 4;
+
+    // 默认背景颜色设置为黄色
+    public static final int BG_DEFAULT_COLOR = YELLOW;
+
+    // 定义文本大小资源的静态常量
+    public static final int TEXT_SMALL        = 0;
+    public static final int TEXT_MEDIUM       = 1;
+    public static final int TEXT_LARGE        = 2;
+    public static final int TEXT_SUPER        = 3;
+
+    // 默认文本大小设置为中等
+    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
+
+    // NoteBgResources内部类，用于获取编辑界面的背景资源
+    public static class NoteBgResources {
+        // 定义编辑界面背景和标题背景的资源ID数组
+        private final static int [] BG_EDIT_RESOURCES = new int [] {
+                R.drawable.edit_yellow,
+                R.drawable.edit_blue,
+                R.drawable.edit_white,
+                R.drawable.edit_green,
+                R.drawable.edit_red
+        };
+
+        private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
+                R.drawable.edit_title_yellow,
+                R.drawable.edit_title_blue,
+                R.drawable.edit_title_white,
+                R.drawable.edit_title_green,
+                R.drawable.edit_title_red
+        };
+
+        // 根据ID获取编辑界面背景资源
+        public static int getNoteBgResource(int id) {
+            return BG_EDIT_RESOURCES[id];
+        }
+
+        // 根据ID获取编辑界面标题背景资源
+        public static int getNoteTitleBgResource(int id) {
+            return BG_EDIT_TITLE_RESOURCES[id];
+        }
+    }
+
+    // 获取默认背景ID的方法，考虑用户偏好设置
+    public static int getDefaultBgId(Context context) {
+        // 从偏好设置中获取背景颜色设置，如果用户已设置，则随机选择一个背景颜色
+        // 否则返回默认颜色BG_DEFAULT_COLOR
+        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
+                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
+            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
+        } else {
+            return BG_DEFAULT_COLOR;
+        }
+    }
+
+    // NoteItemBgResources内部类，用于获取列表项的背景资源
+    public static class NoteItemBgResources {
+        // 定义列表项不同位置的背景资源ID数组
+        private final static int [] BG_FIRST_RESOURCES = new int [] {
+                R.drawable.list_yellow_up,
+                R.drawable.list_blue_up,
+                R.drawable.list_white_up,
+                R.drawable.list_green_up,
+                R.drawable.list_red_up
+        };
+
+        private final static int [] BG_NORMAL_RESOURCES = new int [] {
+                R.drawable.list_yellow_middle,
+                R.drawable.list_blue_middle,
+                R.drawable.list_white_middle,
+                R.drawable.list_green_middle,
+                R.drawable.list_red_middle
+        };
+
+        private final static int [] BG_LAST_RESOURCES = new int [] {
+                R.drawable.list_yellow_down,
+                R.drawable.list_blue_down,
+                R.drawable.list_white_down,
+                R.drawable.list_green_down,
+                R.drawable.list_red_down,
+        };
+
+        private final static int [] BG_SINGLE_RESOURCES = new int [] {
+                R.drawable.list_yellow_single,
+                R.drawable.list_blue_single,
+                R.drawable.list_white_single,
+                R.drawable.list_green_single,
+                R.drawable.list_red_single
+        };
+
+        // 根据ID获取不同位置的背景资源
+        public static int getNoteBgFirstRes(int id) {
+            return BG_FIRST_RESOURCES[id];
+        }
+
+        public static int getNoteBgLastRes(int id) {
+            return BG_LAST_RESOURCES[id];
+        }
+
+        public static int getNoteBgSingleRes(int id) {
+            return BG_SINGLE_RESOURCES[id];
+        }
+
+        public static int getNoteBgNormalRes(int id) {
+            return BG_NORMAL_RESOURCES[id];
+        }
+
+        // 获取文件夹背景资源的方法
+        public static int getFolderBgRes() {
+            return R.drawable.list_folder;
+        }
+    }
+
+    // WidgetBgResources内部类，用于获取小部件的背景资源
+    public static class WidgetBgResources {
+        // 定义小部件背景资源ID数组
+        private final static int [] BG_2X_RESOURCES = new int [] {
+                R.drawable.widget_2x_yellow,
+                R.drawable.widget_2x_blue,
+                R.drawable.widget_2x_white,
+                R.drawable.widget_2x_green,
+                R.drawable.widget_2x_red,
+        };
+
+        // 根据ID获取2倍尺寸小部件背景资源
+        public static int getWidget2xBgResource(int id) {
+            return BG_2X_RESOURCES[id];
+        }
+
+        // 定义4倍尺寸小部件背景资源ID数组
+        private final static int [] BG_4X_RESOURCES = new int [] {
+                R.drawable.widget_4x_yellow,
+                R.drawable.widget_4x_blue,
+                R.drawable.widget_4x_white,
+                R.drawable.widget_4x_green,
+                R.drawable.widget_4x_red
+        };
+
+        // 根据ID获取4倍尺寸小部件背景资源
+        public static int getWidget4xBgResource(int id) {
+            return BG_4X_RESOURCES[id];
+        }
+    }
+
+    // TextAppearanceResources内部类，用于获取文本外观样式资源
+    public static class TextAppearanceResources {
+        // 定义文本外观样式资源ID数组
+        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
+                R.style.TextAppearanceNormal,
+                R.style.TextAppearanceMedium,
+                R.style.TextAppearanceLarge,
+                R.style.TextAppearanceSuper
+        };
+
+        // 根据ID获取文本外观样式资源，如果ID超出范围则返回默认文本大小
+        public static int getTexAppearanceResource(int id) {
+            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
+                return BG_DEFAULT_FONT_SIZE;
+            }
+            return TEXTAPPEARANCE_RESOURCES[id];
+        }
+
+        // 获取文本外观样式资源数组的长度
+        public static int getResourcesSize() {
+            return TEXTAPPEARANCE_RESOURCES.length;
+        }
+    }
+}

ui/AlarmAlertActivity.java

@@ -0,0 +1,190 @@
+/*
+ * 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.ui;
+
+// 导入Android框架中用于对话框、音频、媒体播放等相关功能的类
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.DialogInterface.OnDismissListener;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.provider.Settings;
+import android.view.Window;
+import android.view.WindowManager;
+
+// 导入应用程序自己的资源和工具类
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.DataUtils;
+
+// 导入Java的IO功能，用于处理可能的输入输出异常
+import java.io.IOException;
+
+// 定义AlarmAlertActivity类，它是一个Activity，用于显示闹钟提醒
+public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
+    // 定义成员变量，用于存储笔记的ID和预览文本
+    private long mNoteId;
+    private String mSnippet;
+    // 定义一个常量，用于限制预览文本的最大长度
+    private static final int SNIPPET_PREW_MAX_LEN = 60;
+    // 定义MediaPlayer对象，用于播放闹钟声音
+    MediaPlayer mPlayer;
+
+    // onCreate方法，当Activity创建时被调用
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        // 请求无标题的窗口特性
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+
+        // 获取当前窗口，并添加标记以确保即使在锁屏时也能显示
+        final Window win = getWindow();
+        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+
+        // 检查屏幕是否已经开启，如果没有，则添加标记以保持屏幕开启
+        if (!isScreenOn()) {
+            win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+                    | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+                    | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
+                    | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
+        }
+
+        // 获取启动Activity的Intent
+        Intent intent = getIntent();
+
+        try {
+            // 从Intent中获取笔记ID
+            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
+            // 根据笔记ID获取笔记的预览文本
+            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
+            // 如果预览文本超过最大长度，则截断并添加省略号
+            mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
+                    SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
+                    : mSnippet;
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+            return;
+        }
+
+        // 创建MediaPlayer对象
+        mPlayer = new MediaPlayer();
+        // 如果笔记存在于数据库中，则显示操作对话框并播放闹钟声音
+        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
+            showActionDialog();
+            playAlarmSound();
+        } else {
+            // 如果笔记不存在，则结束Activity
+            finish();
+        }
+    }
+
+    // 检查屏幕是否开启
+    private boolean isScreenOn() {
+        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+        return pm.isScreenOn();
+    }
+
+    // 播放闹钟声音
+    private void playAlarmSound() {
+        // 获取默认闹钟铃声的Uri
+        Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
+
+        // 获取受影响的音频流类型
+        int silentModeStreams = Settings.System.getInt(getContentResolver(),
+                Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
+
+        // 如果闹钟铃声被静音模式影响，则设置MediaPlayer的音频流类型
+        if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
+            mPlayer.setAudioStreamType(silentModeStreams);
+        } else {
+            mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
+        }
+        try {
+            // 设置MediaPlayer的数据源为闹钟铃声，并准备播放
+            mPlayer.setDataSource(this, url);
+            mPlayer.prepare();
+            mPlayer.setLooping(true);
+            mPlayer.start();
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            e.printStackTrace();
+        } catch (IllegalStateException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // 显示操作对话框
+    private void showActionDialog() {
+        // 创建AlertDialog.Builder对象
+        AlertDialog.Builder dialog = new AlertDialog.Builder(this);
+        // 设置对话框标题和消息
+        dialog.setTitle(R.string.app_name);
+        dialog.setMessage(mSnippet);
+        // 设置对话框的肯定按钮，并添加点击事件监听器
+        dialog.setPositiveButton(R.string.notealert_ok, this);
+        // 如果屏幕已经开启，则设置对话框的否定按钮
+        if (isScreenOn()) {
+            dialog.setNegativeButton(R.string.notealert_enter, this);
+        }
+        // 显示对话框，并添加消失事件监听器
+        dialog.show().setOnDismissListener(this);
+    }
+
+    // 点击事件处理方法
+    public void onClick(DialogInterface dialog, int which) {
+        switch (which) {
+            case DialogInterface.BUTTON_NEGATIVE:
+                // 如果用户点击否定按钮，则启动NoteEditActivity
+                Intent intent = new Intent(this, NoteEditActivity.class);
+                intent.setAction(Intent.ACTION_VIEW);
+                intent.putExtra(Intent.EXTRA_UID, mNoteId);
+                startActivity(intent);
+                break;
+            default:
+                // 默认不做任何操作
+                break;
+        }
+    }
+
+    // 对话框消失事件处理方法
+    public void onDismiss(DialogInterface dialog) {
+        // 停止闹钟声音，并结束Activity
+        stopAlarmSound();
+        finish();
+    }
+
+    // 停止闹钟声音
+    private void stopAlarmSound() {
+        // 如果MediaPlayer对象不为空，则停止播放并释放资源
+        if (mPlayer != null) {
+            mPlayer.stop();
+            mPlayer.release();
+            mPlayer = null;
+        }
+    }
+}

ui/AlarmInitReceiver.java

@@ -0,0 +1,89 @@
+/*
+ * 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.
+ */
+// 这里是文件的版权声明，说明代码版权归属于MiCode开源社区，并在Apache License 2.0下授权。
+
+package net.micode.notes.ui;
+// 声明代码所属的包名。
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+// 导入所需的Android类和接口，以及应用内部的数据访问类。
+
+public class AlarmInitReceiver extends BroadcastReceiver {
+    // 定义一个继承自BroadcastReceiver的类，用于处理广播事件。
+
+    private static final String [] PROJECTION = new String [] {
+            NoteColumns.ID,
+            NoteColumns.ALERTED_DATE
+    };
+    // 定义查询数据库时需要的列。
+
+    private static final int COLUMN_ID                = 0;
+    private static final int COLUMN_ALERTED_DATE      = 1;
+    // 定义列索引常量。
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // 实现onReceive方法，这是BroadcastReceiver的核心方法，用于处理接收到的广播。
+
+        long currentDate = System.currentTimeMillis();
+        // 获取当前时间的毫秒值。
+
+        Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                PROJECTION,
+                NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
+                new String[] { String.valueOf(currentDate) },
+                null);
+        // 查询数据库，获取所有未提醒且类型为笔记的记录。
+
+        if (c != null) {
+            if (c.moveToFirst()) {
+                do {
+                    long alertDate = c.getLong(COLUMN_ALERTED_DATE);
+                    // 获取每条记录的提醒日期。
+
+                    Intent sender = new Intent(context, AlarmReceiver.class);
+                    // 创建一个新的Intent，用于触发AlarmReceiver。
+
+                    sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
+                    // 设置Intent的数据，以便AlarmReceiver知道要处理哪个笔记。
+
+                    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
+                    // 创建一个PendingIntent，用于AlarmManager设置闹钟。
+
+                    AlarmManager alermManager = (AlarmManager) context
+                            .getSystemService(Context.ALARM_SERVICE);
+                    // 获取AlarmManager服务。
+
+                    alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
+                    // 设置闹钟，当到达提醒日期时，AlarmManager将触发AlarmReceiver。
+
+                } while (c.moveToNext());
+                // 遍历查询结果，为每条记录设置闹钟。
+            }
+            c.close();
+            // 关闭Cursor。
+        }
+    }
+}

ui/AlarmReceiver.java

@@ -0,0 +1,39 @@
+/*
+ * 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.ui;
+
+// 导入Android框架中用于接收广播和启动Activity的类
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+// 定义AlarmReceiver类，继承自BroadcastReceiver
+public class AlarmReceiver extends BroadcastReceiver {
+    // onReceive方法，是BroadcastReceiver的核心方法，当接收到广播时被调用
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // 将接收到的Intent的类设置为AlarmAlertActivity，即当接收到广播时，启动AlarmAlertActivity
+        intent.setClass(context, AlarmAlertActivity.class);
+
+        // 为Intent添加FLAG_ACTIVITY_NEW_TASK标志，使得即使应用程序不在前台也能启动Activity
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+        // 使用context启动AlarmAlertActivity
+        context.startActivity(intent);
+    }
+}

ui/DateTimePicker.java

@@ -0,0 +1,541 @@
+/**
+ * 版权声明，说明该文件由MiCode开源社区提供，并根据Apache License 2.0授权使用。
+ */
+        /*
+         * 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.ui;
+
+import java.text.DateFormatSymbols;
+import java.util.Calendar;
+
+import net.micode.notes.R;
+
+
+import android.content.Context;
+import android.text.format.DateFormat;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.NumberPicker;
+
+/**
+ * DateTimePicker 类允许用户通过图形界面选择日期和时间。
+ */
+public class DateTimePicker extends FrameLayout {
+
+    // 默认启用状态
+    private static final boolean DEFAULT_ENABLE_STATE = true;
+
+    // 时间和日期的常量
+    private static final int HOURS_IN_HALF_DAY = 12;
+    private static final int HOURS_IN_ALL_DAY = 24;
+    private static final int DAYS_IN_ALL_WEEK = 7;
+    private static final int DATE_SPINNER_MIN_VAL = 0;
+    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
+    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
+    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
+    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
+    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
+    private static final int MINUT_SPINNER_MIN_VAL = 0;
+    private static final int MINUT_SPINNER_MAX_VAL = 59;
+    private static final int AMPM_SPINNER_MIN_VAL = 0;
+    private static final int AMPM_SPINNER_MAX_VAL = 1;
+
+    // 日期时间选择器的组件
+    private final NumberPicker mDateSpinner;
+    private final NumberPicker mHourSpinner;
+    private final NumberPicker mMinuteSpinner;
+    private final NumberPicker mAmPmSpinner;
+    private Calendar mDate;
+
+    // 日期显示值
+    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
+
+    // AM/PM状态
+    private boolean mIsAm;
+
+    // 24小时制状态
+    private boolean mIs24HourView;
+
+    // 启用状态
+    private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
+
+    // 初始化状态
+    private boolean mInitialising;
+
+    // 日期时间改变的监听器
+    private OnDateTimeChangedListener mOnDateTimeChangedListener;
+
+    // 日期改变的监听器
+    private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
+            updateDateControl();
+            onDateTimeChanged();
+        }
+    };
+
+    // 小时改变的监听器
+    private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            boolean isDateChanged = false;
+            Calendar cal = Calendar.getInstance();
+            // 处理12小时制和24小时制的切换
+            if (!mIs24HourView) {
+                if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, 1);
+                    isDateChanged = true;
+                } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, -1);
+                    isDateChanged = true;
+                }
+                if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
+                        oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+                    mIsAm = !mIsAm;
+                    updateAmPmControl();
+                }
+            } else {
+                if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, 1);
+                    isDateChanged = true;
+                } else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
+                    cal.setTimeInMillis(mDate.getTimeInMillis());
+                    cal.add(Calendar.DAY_OF_YEAR, -1);
+                    isDateChanged = true;
+                }
+            }
+            int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
+            mDate.set(Calendar.HOUR_OF_DAY, newHour);
+            onDateTimeChanged();
+            if (isDateChanged) {
+                setCurrentYear(cal.get(Calendar.YEAR));
+                setCurrentMonth(cal.get(Calendar.MONTH));
+                setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));
+            }
+        }
+    };
+
+    // 分钟改变的监听器
+    private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            int minValue = mMinuteSpinner.getMinValue();
+            int maxValue = mMinuteSpinner.getMaxValue();
+            int offset = 0;
+            if (oldVal == maxValue && newVal == minValue) {
+                offset += 1;
+            } else if (oldVal == minValue && newVal == maxValue) {
+                offset -= 1;
+            }
+            if (offset != 0) {
+                mDate.add(Calendar.HOUR_OF_DAY, offset);
+                mHourSpinner.setValue(getCurrentHour());
+                updateDateControl();
+                int newHour = getCurrentHourOfDay();
+                if (newHour >= HOURS_IN_HALF_DAY) {
+                    mIsAm = false;
+                    updateAmPmControl();
+                } else {
+                    mIsAm = true;
+                    updateAmPmControl();
+                }
+            }
+            mDate.set(Calendar.MINUTE, newVal);
+            onDateTimeChanged();
+        }
+    };
+
+    // AM/PM改变的监听器
+    private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+        @Override
+        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+            mIsAm = !mIsAm;
+            if (mIsAm) {
+                mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
+            } else {
+                mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
+            }
+            updateAmPmControl();
+            onDateTimeChanged();
+        }
+    };
+
+    // 日期时间改变的回调接口
+    public interface OnDateTimeChangedListener {
+        void onDateTimeChanged(DateTimePicker view, int year, int month,
+                               int dayOfMonth, int hourOfDay, int minute);
+    }
+
+    // DateTimePicker的构造函数
+    public DateTimePicker(Context context) {
+        this(context, System.currentTimeMillis());
+    }
+
+    public DateTimePicker(Context context, long date) {
+        this(context, date, DateFormat.is24HourFormat(context));
+    }
+
+    public DateTimePicker(Context context, long date, boolean is24HourView) {
+        super(context); // 调用 FrameLayout 的构造函数，因为 DateTimePicker 继承自 FrameLayout
+        mDate = Calendar.getInstance(); // 获取当前日期和时间的 Calendar 实例
+        mInitialising = true; // 设置初始化标志为 true，表示正在初始化控件
+        mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY; // 根据当前时间判断是 AM 还是 PM
+
+        // 将 datetime_picker.xml 布局文件加载到 DateTimePicker 中
+        inflate(context, R.layout.datetime_picker, this);
+
+        // 初始化日期选择器，并设置其最小值和最大值，以及值改变监听器
+        mDateSpinner = (NumberPicker) findViewById(R.id.date);
+        mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
+        mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
+        mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
+
+        // 初始化小时选择器，并设置其值改变监听器
+        mHourSpinner = (NumberPicker) findViewById(R.id.hour);
+        mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
+
+        // 初始化分钟选择器，并设置其最小值和最大值，以及长按更新间隔和值改变监听器
+        mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
+        mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
+        mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
+        mMinuteSpinner.setOnLongPressUpdateInterval(100); // 设置长按选择器更新间隔为 100 毫秒
+        mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
+
+        // 初始化 AM/PM 选择器，并设置其最小值和最大值，以及显示值和值改变监听器
+        String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings(); // 获取系统本地化的 AM/PM 字符串
+        mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
+        mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
+        mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
+        mAmPmSpinner.setDisplayedValues(stringsForAmPm); // 设置 AM/PM 选择器的显示值
+        mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
+
+        // 更新日期、小时和 AM/PM 控件的状态
+        updateDateControl();
+        updateHourControl();
+        updateAmPmControl();
+
+        // 设置是否为24小时制视图
+        set24HourView(is24HourView);
+
+        // 设置当前时间
+        setCurrentDate(date);
+
+        // 设置控件的启用状态
+        setEnabled(isEnabled());
+
+        // 设置内容描述，用于辅助功能
+        mInitialising = false;
+    }
+
+    // 设置控件的启用状态
+    @Override
+    public void setEnabled(boolean enabled) {
+        if (mIsEnabled == enabled) {
+            return;
+        }
+        super.setEnabled(enabled);
+        mDateSpinner.setEnabled(enabled);
+        mMinuteSpinner.setEnabled(enabled);
+        mHourSpinner.setEnabled(enabled);
+        mAmPmSpinner.setEnabled(enabled);
+        mIsEnabled = enabled;
+    }
+
+    // 获取控件的启用状态
+    @Override
+    public boolean isEnabled() {
+        return mIsEnabled;
+    }
+
+    /**
+     * 获取当前日期时间的毫秒值。
+     *
+     * @return 当前日期时间的毫秒值。
+     */
+    public long getCurrentDateInTimeMillis() {
+        return mDate.getTimeInMillis();
+    }
+
+    /**
+     * 设置当前日期时间。
+     *
+     * @param date 要设置的日期时间的毫秒值。
+     */
+    public void setCurrentDate(long date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTimeInMillis(date);
+        setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
+                cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
+    }
+
+    /**
+     * 设置当前日期。
+     *
+     * @param year 年。
+     * @param month 月。
+     * @param dayOfMonth 日。
+     * @param hourOfDay 24小时制的小时。
+     * @param minute 分钟。
+     */
+    public void setCurrentDate(int year, int month,
+                               int dayOfMonth, int hourOfDay, int minute) {
+        setCurrentYear(year);
+        setCurrentMonth(month);
+        setCurrentDay(dayOfMonth);
+        setCurrentHour(hourOfDay);
+        setCurrentMinute(minute);
+    }
+
+    /**
+     * 获取当前年。
+     *
+     * @return 当前年。
+     */
+    public int getCurrentYear() {
+        return mDate.get(Calendar.YEAR);
+    }
+
+    /**
+     * 设置当前年。
+     *
+     * @param year 要设置的年份。
+     */
+    public void setCurrentYear(int year) {
+        if (!mInitialising && year == getCurrentYear()) {
+            return;
+        }
+        mDate.set(Calendar.YEAR, year);
+        updateDateControl();
+        onDateTimeChanged();
+    }
+
+    /**
+     * 获取当前月。
+     *
+     * @return 当前月。
+     */
+    public int getCurrentMonth() {
+        return mDate.get(Calendar.MONTH);
+    }
+
+    /**
+     * 设置当前月。
+     *
+     * @param month 要设置的月份（0-11）。
+     */
+    public void setCurrentMonth(int month) {
+        if (!mInitialising && month == getCurrentMonth()) {
+            return;
+        }
+        mDate.set(Calendar.MONTH, month);
+        updateDateControl();
+        onDateTimeChanged();
+    }
+
+    /**
+     * 获取当前日。
+     *
+     * @return 当前日。
+     */
+    public int getCurrentDay() {
+        return mDate.get(Calendar.DAY_OF_MONTH);
+    }
+
+    /**
+     * 设置当前日。
+     *
+     * @param dayOfMonth 要设置的日期。
+     */
+    public void setCurrentDay(int dayOfMonth) {
+        if (!mInitialising && dayOfMonth == getCurrentDay()) {
+            return;
+        }
+        mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+        updateDateControl();
+        onDateTimeChanged();
+    }
+
+    /**
+     * 获取当前小时（24小时制）。
+     *
+     * @return 当前小时。
+     */
+    public int getCurrentHourOfDay() {
+        return mDate.get(Calendar.HOUR_OF_DAY);
+    }
+
+    /**
+     * 获取当前小时（12小时制）。
+     *
+     * @return 当前小时。
+     */
+    private int getCurrentHour() {
+        if (mIs24HourView){
+            return getCurrentHourOfDay();
+        } else {
+            int hour = getCurrentHourOfDay();
+            if (hour > HOURS_IN_HALF_DAY) {
+                return hour - HOURS_IN_HALF_DAY;
+            } else {
+                return hour == 0 ? HOURS_IN_HALF_DAY : hour;
+            }
+        }
+    }
+
+    /**
+     * 设置当前小时（24小时制）。
+     *
+     * @param hourOfDay 要设置的小时。
+     */
+    public void setCurrentHour(int hourOfDay) {
+        if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
+            return;
+        }
+        mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+        if (!mIs24HourView) {
+            if (hourOfDay >= HOURS_IN_HALF_DAY) {
+                mIsAm = false;
+                if (hourOfDay > HOURS_IN_HALF_DAY) {
+                    hourOfDay -= HOURS_IN_HALF_DAY;
+                }
+            } else {
+                mIsAm = true;
+                if (hourOfDay == 0) {
+                    hourOfDay = HOURS_IN_HALF_DAY;
+                }
+            }
+            updateAmPmControl();
+        }
+        mHourSpinner.setValue(hourOfDay);
+        onDateTimeChanged();
+    }
+
+    /**
+     * 获取当前分钟。
+     *
+     * @return 当前分钟。
+     */
+    public int getCurrentMinute() {
+        return mDate.get(Calendar.MINUTE);
+    }
+
+    /**
+     * 设置当前分钟。
+     *
+     * @param minute 要设置的分钟。
+     */
+    public void setCurrentMinute(int minute) {
+        if (!mInitialising && minute == getCurrentMinute()) {
+            return;
+        }
+        mMinuteSpinner.setValue(minute);
+        mDate.set(Calendar.MINUTE, minute);
+        onDateTimeChanged();
+    }
+
+    /**
+     * 检查是否为24小时制视图。
+     *
+     * @return 如果是24小时制视图返回true，否则返回false。
+     */
+    public boolean is24HourView() {
+        return mIs24HourView;
+    }
+
+    /**
+     * 设置是否为24小时制或AM/PM制。
+     *
+     * @param is24HourView 如果为true，则设置为24小时制，否则设置为AM/PM制。
+     */
+    public void set24HourView(boolean is24HourView) {
+        if (mIs24HourView == is24HourView) {
+            return;
+        }
+        mIs24HourView = is24HourView;
+        mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
+        int hour = getCurrentHourOfDay();
+        updateHourControl();
+        setCurrentHour(hour);
+        updateAmPmControl();
+    }
+
+    /**
+     * 更新日期控件的显示。
+     */
+    private void updateDateControl() {
+        Calendar cal = Calendar.getInstance();
+        cal.setTimeInMillis(mDate.getTimeInMillis());
+        cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
+        mDateSpinner.setDisplayedValues(null);
+        for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
+            cal.add(Calendar.DAY_OF_YEAR, 1);
+            mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
+        }
+        mDateSpinner.setDisplayedValues(mDateDisplayValues);
+        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
+        mDateSpinner.invalidate();
+    }
+
+    /**
+     * 更新AM/PM控件的显示。
+     */
+    private void updateAmPmControl() {
+        if (mIs24HourView) {
+            mAmPmSpinner.setVisibility(View.GONE);
+        } else {
+            int index = mIsAm ? Calendar.AM : Calendar.PM;
+            mAmPmSpinner.setValue(index);
+            mAmPmSpinner.setVisibility(View.VISIBLE);
+        }
+    }
+
+    /**
+     * 更新小时控件的显示。
+     */
+    private void updateHourControl() {
+        if (mIs24HourView) {
+            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
+            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
+        } else {
+            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
+            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
+        }
+    }
+
+    /**
+     * 设置日期时间改变的回调监听器。
+     *
+     * @param callback 回调接口，如果为null则不进行任何操作。
+     */
+    public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
+        mOnDateTimeChangedListener = callback;
+    }
+
+    /**
+     * 当日期时间改变时调用的回调方法。
+     */
+    private void onDateTimeChanged() {
+        if (mOnDateTimeChangedListener != null) {
+            mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
+                    getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
+        }
+    }
+}

ui/DateTimePickerDialog.java

@@ -0,0 +1,135 @@
+/*
+ * 版权声明，说明该文件由MiCode开源社区提供，并根据Apache License 2.0授权使用。
+ */
+/*
+ * 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.ui;
+
+import java.util.Calendar;
+
+import net.micode.notes.R;
+import net.micode.notes.ui.DateTimePicker;
+import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.text.format.DateFormat;
+import android.text.format.DateUtils;
+
+/**
+ * DateTimePickerDialog 类是一个继承自 AlertDialog 的对话框，用于让用户选择日期和时间。
+ */
+public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
+
+    // 当前日期时间的 Calendar 对象
+    private Calendar mDate = Calendar.getInstance();
+    // 是否使用24小时制的布尔值
+    private boolean mIs24HourView;
+    // 日期时间设置监听器
+    private OnDateTimeSetListener mOnDateTimeSetListener;
+    // DateTimePicker 对象
+    private DateTimePicker mDateTimePicker;
+
+    /**
+     * OnDateTimeSetListener 接口定义了一个方法 OnDateTimeSet，用于通知监听器日期时间已被设置。
+     */
+    public interface OnDateTimeSetListener {
+        void OnDateTimeSet(AlertDialog dialog, long date);
+    }
+
+    /**
+     * DateTimePickerDialog 的构造函数，初始化对话框并设置日期时间。
+     *
+     * @param context 上下文对象。
+     * @param date    初始日期时间的毫秒表示。
+     */
+    public DateTimePickerDialog(Context context, long date) {
+        super(context);
+        mDateTimePicker = new DateTimePicker(context);
+        setView(mDateTimePicker);
+        // 设置 DateTimePicker 的日期时间改变监听器
+        mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
+            public void onDateTimeChanged(DateTimePicker view, int year, int month,
+                                          int dayOfMonth, int hourOfDay, int minute) {
+                mDate.set(Calendar.YEAR, year);
+                mDate.set(Calendar.MONTH, month);
+                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+                mDate.set(Calendar.MINUTE, minute);
+                updateTitle(mDate.getTimeInMillis());
+            }
+        });
+        mDate.setTimeInMillis(date);
+        mDate.set(Calendar.SECOND, 0);
+        mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
+        // 设置对话框的按钮
+        setButton(context.getString(R.string.datetime_dialog_ok), this);
+        setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
+        // 设置是否使用24小时制
+        set24HourView(DateFormat.is24HourFormat(this.getContext()));
+        updateTitle(mDate.getTimeInMillis());
+    }
+
+    /**
+     * 设置是否使用24小时制。
+     *
+     * @param is24HourView 是否使用24小时制。
+     */
+    public void set24HourView(boolean is24HourView) {
+        mIs24HourView = is24HourView;
+        if (mDateTimePicker != null) {
+            mDateTimePicker.set24HourView(is24HourView);
+        }
+    }
+
+    /**
+     * 设置日期时间设置监听器。
+     *
+     * @param callBack 监听器对象。
+     */
+    public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
+        mOnDateTimeSetListener = callBack;
+    }
+
+    /**
+     * 更新对话框标题为当前选择的日期时间。
+     *
+     * @param date 毫秒表示的日期时间。
+     */
+    private void updateTitle(long date) {
+        int flag =
+                DateUtils.FORMAT_SHOW_YEAR |
+                        DateUtils.FORMAT_SHOW_DATE |
+                        DateUtils.FORMAT_SHOW_TIME;
+        flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_12HOUR;
+        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
+    }
+
+    /**
+     * 点击事件处理，当点击确定按钮时调用。
+     *
+     * @param arg0 DialogInterface 对象。
+     * @param arg1 按钮索引。
+     */
+    public void onClick(DialogInterface arg0, int arg1) {
+        if (mOnDateTimeSetListener != null) {
+            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
+        }
+    }
+}

ui/DropdownMenu.java

@@ -0,0 +1,98 @@
+/*
+ * 版权声明，说明该文件由MiCode开源社区提供，并根据Apache License 2.0授权使用。
+ */
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.PopupMenu;
+import android.widget.PopupMenu.OnMenuItemClickListener;
+
+import net.micode.notes.R;
+
+/**
+ * DropdownMenu 类用于创建一个下拉菜单（Dropdown Menu），依附于一个按钮上。
+ */
+public class DropdownMenu {
+    // 按钮，用于触发下拉菜单的显示
+    private Button mButton;
+    // 弹出菜单对象
+    private PopupMenu mPopupMenu;
+    // 菜单对象，用于操作菜单项
+    private Menu mMenu;
+
+    /**
+     * DropdownMenu 的构造函数，初始化下拉菜单。
+     *
+     * @param context 上下文对象，用于获取资源和创建视图。
+     * @param button 触发下拉菜单显示的按钮。
+     * @param menuId 要加载的菜单资源ID。
+     */
+    public DropdownMenu(Context context, Button button, int menuId) {
+        mButton = button;
+        // 设置按钮的背景资源为下拉图标
+        mButton.setBackgroundResource(R.drawable.dropdown_icon);
+        // 创建PopupMenu对象，并传入按钮作为锚点
+        mPopupMenu = new PopupMenu(context, mButton);
+        // 获取PopupMenu的Menu对象
+        mMenu = mPopupMenu.getMenu();
+        // 通过menuId加载菜单项
+        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+        // 设置按钮的点击事件监听器，点击时显示PopupMenu
+        mButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                mPopupMenu.show();
+            }
+        });
+    }
+
+    /**
+     * 设置下拉菜单项点击事件的监听器。
+     *
+     * @param listener 菜单项点击事件监听器。
+     */
+    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
+        if (mPopupMenu != null) {
+            mPopupMenu.setOnMenuItemClickListener(listener);
+        }
+    }
+
+    /**
+     * 根据ID查找菜单项。
+     *
+     * @param id 菜单项的ID。
+     * @return 菜单项对象。
+     */
+    public MenuItem findItem(int id) {
+        return mMenu.findItem(id);
+    }
+
+    /**
+     * 设置下拉菜单按钮的标题。
+     *
+     * @param title 要设置的标题。
+     */
+    public void setTitle(CharSequence title) {
+        mButton.setText(title);
+    }
+}

ui/FoldersListAdapter.java

@@ -0,0 +1,93 @@
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+// 定义一个继承自CursorAdapter的类，用于适配文件夹列表的数据
+public class FoldersListAdapter extends CursorAdapter {
+    // 定义查询数据库时需要的列
+    public static final String [] PROJECTION = {
+            NoteColumns.ID,
+            NoteColumns.SNIPPET
+    };
+
+    // 定义列索引常量
+    public static final int ID_COLUMN   = 0;
+    public static final int NAME_COLUMN = 1;
+
+    // 构造函数，初始化上下文和游标
+    public FoldersListAdapter(Context context, Cursor c) {
+        super(context, c);
+        // TODO Auto-generated constructor stub
+    }
+
+    // 新建视图的方法，返回一个FolderListItem对象
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new FolderListItem(context);
+    }
+
+    // 绑定视图和数据的方法，将游标中的数据设置到视图上
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        if (view instanceof FolderListItem) {
+            // 获取文件夹名称，如果是根文件夹则使用特殊字符串
+            String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+                    .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+            // 将文件夹名称设置到视图上
+            ((FolderListItem) view).bind(folderName);
+        }
+    }
+
+    // 根据位置获取文件夹名称的方法
+    public String getFolderName(Context context, int position) {
+        Cursor cursor = (Cursor) getItem(position);
+        return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+                .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+    }
+
+    // 定义一个内部类FolderListItem，继承自LinearLayout
+    private class FolderListItem extends LinearLayout {
+        // 定义一个TextView用于显示文件夹名称
+        private TextView mName;
+
+        // FolderListItem的构造函数，初始化布局和TextView
+        public FolderListItem(Context context) {
+            super(context);
+            inflate(context, R.layout.folder_list_item, this);
+            mName = (TextView) findViewById(R.id.tv_folder_name);
+        }
+
+        // 绑定文件夹名称到TextView的方法
+        public void bind(String name) {
+            mName.setText(name);
+        }
+    }
+
+}

ui/NoteEditActivity.java

@@ -0,0 +1,979 @@
+/*
+ * 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.ui;
+
+// 导入所需的Android类和接口
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.app.AlertDialog;
+import android.app.PendingIntent;
+import android.app.SearchManager;
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.graphics.Paint;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.Spannable;
+import android.text.SpannableString;
+import android.text.TextUtils;
+import android.text.format.DateUtils;
+import android.text.style.BackgroundColorSpan;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.WindowManager;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.CompoundButton.OnCheckedChangeListener;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.model.WorkingNote;
+import net.micode.notes.model.WorkingNote.NoteSettingChangedListener;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser;
+import net.micode.notes.tool.ResourceParser.TextAppearanceResources;
+import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener;
+import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener;
+import net.micode.notes.widget.NoteWidgetProvider_2x;
+import net.micode.notes.widget.NoteWidgetProvider_4x;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+// NoteEditActivity类继承自Activity类，用于编辑笔记
+public class NoteEditActivity extends Activity implements OnClickListener,
+        NoteSettingChangedListener, OnTextViewChangeListener {
+    // 内部类HeadViewHolder，用于持有笔记头部视图的引用
+    private class HeadViewHolder {
+        public TextView tvModified; // 显示最后修改时间的TextView
+        public ImageView ivAlertIcon; // 闹钟提醒图标的ImageView
+        public TextView tvAlertDate; // 显示闹钟提醒日期的TextView
+        public ImageView ibSetBgColor; // 设置背景颜色的ImageView
+    }
+
+    // 定义了一些静态的Map，用于存储背景颜色选择器按钮和字体大小选择器按钮的ID与它们对应的值之间的映射关系
+    private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
+    static {
+        // 初始化背景颜色选择器按钮和值的映射
+        sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN);
+        sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
+    }
+
+    private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
+    static {
+        // 初始化背景颜色选择器选中状态和值的映射
+        sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
+        sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select);
+        sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select);
+        sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select);
+        sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
+    }
+
+    private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
+    static {
+        // 初始化字体大小选择器按钮和值的映射
+        sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
+        sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL);
+        sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM);
+        sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
+    }
+
+    private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
+    static {
+        // 初始化字体大小选择器选中状态和值的映射
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select);
+        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
+    }
+
+    private static final String TAG = "NoteEditActivity"; // 用于日志输出的TAG
+
+    private HeadViewHolder mNoteHeaderHolder; // 持有笔记头部视图的引用
+    private View mHeadViewPanel; // 笔记头部视图面板
+    private View mNoteBgColorSelector; // 笔记背景颜色选择器
+    private View mFontSizeSelector; // 字体大小选择器
+    private EditText mNoteEditor; // 笔记编辑器
+    private View mNoteEditorPanel; // 笔记编辑器面板
+    private WorkingNote mWorkingNote; // 正在编辑的笔记
+    private SharedPreferences mSharedPrefs; // SharedPreferences对象，用于存储设置
+    private int mFontSizeId; // 字体大小ID
+
+    private static final String PREFERENCE_FONT_SIZE = "pref_font_size"; // 字体大小设置的键
+
+    private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10; // 快捷方式图标标题的最大长度
+
+    public static final String TAG_CHECKED = String.valueOf('\u221A'); // 标记为已检查的标签
+    public static final String TAG_UNCHECKED = String.valueOf('\u25A1'); // 标记为未检查的标签
+
+    private LinearLayout mEditTextList; // 编辑文本列表
+    private String mUserQuery; // 用户查询字符串
+    private Pattern mPattern; // 用于搜索的正则表达式模式
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        this.setContentView(R.layout.note_edit); // 设置布局文件
+
+        if (savedInstanceState == null && !initActivityState(getIntent())) {
+            finish(); // 如果无法初始化活动状态，则结束活动
+            return;
+        }
+        initResources(); // 初始化资源
+    }
+
+    /**
+     * 当活动被系统杀死后重新创建时，恢复之前的状态
+     */
+    @Override
+    protected void onRestoreInstanceState(Bundle savedInstanceState) {
+        super.onRestoreInstanceState(savedInstanceState);
+        if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
+            if (!initActivityState(intent)) {
+                finish(); // 如果无法初始化活动状态，则结束活动
+                return;
+            }
+            Log.d(TAG, "Restoring from killed activity"); // 日志输出：从被杀死的活动恢复
+        }
+    }
+}
+
+    private boolean initActivityState(Intent intent) {
+        mWorkingNote = null; // 初始化WorkingNote对象为null
+
+        // 如果Intent的Action是VIEW，但是没有提供ID，则跳转到笔记列表活动
+        if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
+            long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0); // 获取笔记ID
+            mUserQuery = "";
+
+            // 如果是从搜索结果开始的
+            if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
+                noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY)); // 从搜索结果中获取笔记ID
+                mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY); // 获取用户查询字符串
+            }
+
+            // 如果笔记ID在数据库中不可见，则跳转到笔记列表活动并显示错误信息
+            if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
+                Intent jump = new Intent(this, NotesListActivity.class);
+                startActivity(jump);
+                showToast(R.string.error_note_not_exist);
+                finish();
+                return false;
+            } else {
+                mWorkingNote = WorkingNote.load(this, noteId); // 加载笔记
+                if (mWorkingNote == null) {
+                    Log.e(TAG, "load note failed with note id" + noteId);
+                    finish();
+                    return false;
+                }
+            }
+            // 设置软键盘输入模式
+            getWindow().setSoftInputMode(
+                    WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
+                            | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+        } else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
+            // 新建笔记
+            long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0); // 获取文件夹ID
+            int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
+                    AppWidgetManager.INVALID_APPWIDGET_ID); // 获取小部件ID
+            int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,
+                    Notes.TYPE_WIDGET_INVALIDE); // 获取小部件类型
+            int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
+                    ResourceParser.getDefaultBgId(this)); // 获取背景资源ID
+
+            // 解析通话记录笔记
+            String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER); // 获取电话号码
+            long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0); // 获取通话日期
+            if (callDate != 0 && phoneNumber != null) {
+                if (TextUtils.isEmpty(phoneNumber)) {
+                    Log.w(TAG, "The call record number is null");
+                }
+                long noteId = 0;
+                if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(),
+                        phoneNumber, callDate)) > 0) {
+                    mWorkingNote = WorkingNote.load(this, noteId); // 加载笔记
+                    if (mWorkingNote == null) {
+                        Log.e(TAG, "load call note failed with note id" + noteId);
+                        finish();
+                        return false;
+                    }
+                } else {
+                    mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
+                            widgetType, bgResId); // 创建空笔记
+                    mWorkingNote.convertToCallNote(phoneNumber, callDate); // 转换为通话笔记
+                }
+            } else {
+                mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
+                        bgResId); // 创建空笔记
+            }
+
+            // 设置软键盘输入模式
+            getWindow().setSoftInputMode(
+                    WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
+                            | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+        } else {
+            Log.e(TAG, "Intent not specified action, should not support");
+            finish();
+            return false;
+        }
+        mWorkingNote.setOnSettingStatusChangedListener(this); // 设置笔记设置状态改变的监听器
+        return true; // 返回true表示成功初始化
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume(); // 调用父类的onResume方法
+        initNoteScreen(); // 初始化笔记屏幕
+    }
+
+    /**
+     * 初始化笔记屏幕，设置笔记编辑器的文本样式、背景颜色等。
+     */
+    private void initNoteScreen() {
+        mNoteEditor.setTextAppearance(this, TextAppearanceResources
+                .getTexAppearanceResource(mFontSizeId)); // 设置笔记编辑器的文本样式
+        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+            switchToListMode(mWorkingNote.getContent()); // 切换到列表模式
+        } else {
+            mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery)); // 设置笔记编辑器的文本
+            mNoteEditor.setSelection(mNoteEditor.getText().length()); // 将光标设置到文本末尾
+        }
+        for (Integer id : sBgSelectorSelectionMap.keySet()) {
+            findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE); // 隐藏所有背景选择器的选中状态
+        }
+        mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId()); // 设置头部视图的背景颜色
+        mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId()); // 设置笔记编辑器面板的背景颜色
+
+        // 设置最后修改时间
+        mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
+                mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
+                        | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
+                        | DateUtils.FORMAT_SHOW_YEAR));
+    }
+
+    /**
+     * 显示提醒头部，如果笔记有设置闹钟提醒，则显示提醒日期和图标。
+     * 目前由于DateTimePicker未准备好，所以该功能被禁用。
+     */
+    showAlertHeader();
+
+    private void showAlertHeader() {
+        // 如果笔记有设置闹钟提醒
+        if (mWorkingNote.hasClockAlert()) {
+            long time = System.currentTimeMillis(); // 获取当前时间
+            // 如果当前时间超过了提醒时间
+            if (time > mWorkingNote.getAlertDate()) {
+                mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired); // 显示提醒已过期
+            } else {
+                // 显示相对时间，例如“1小时后”
+                mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(
+                        mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
+            }
+            mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE); // 显示提醒日期
+            mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE); // 显示提醒图标
+        } else {
+            mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE); // 隐藏提醒日期
+            mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE); // 隐藏提醒图标
+        };
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent); // 调用父类的onNewIntent方法
+        initActivityState(intent); // 重新初始化活动状态
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState); // 调用父类的onSaveInstanceState方法
+        // 对于没有笔记ID的新笔记，我们首先需要保存它以生成ID
+        if (!mWorkingNote.existInDatabase()) {
+            saveNote(); // 保存笔记
+        }
+        outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId()); // 将笔记ID保存到Bundle中
+        Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState"); // 日志输出保存的笔记ID
+    }
+
+    @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        // 如果背景颜色选择器可见，并且触摸事件不在该视图范围内
+        if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
+                && !inRangeOfView(mNoteBgColorSelector, ev)) {
+            mNoteBgColorSelector.setVisibility(View.GONE); // 隐藏背景颜色选择器
+            return true; // 消费事件
+        }
+
+        // 如果字体大小选择器可见，并且触摸事件不在该视图范围内
+        if (mFontSizeSelector.getVisibility() == View.VISIBLE
+                && !inRangeOfView(mFontSizeSelector, ev)) {
+            mFontSizeSelector.setVisibility(View.GONE); // 隐藏字体大小选择器
+            return true; // 消费事件
+        }
+        return super.dispatchTouchEvent(ev); // 继续传递事件
+    }
+
+    /**
+     * 检查触摸事件是否在视图范围内。
+     * @param view 要检查的视图
+     * @param ev 触摸事件
+     * @return 如果触摸事件在视图范围内，返回true；否则返回false。
+     */
+    private boolean inRangeOfView(View view, MotionEvent ev) {
+        int []location = new int[2];
+        view.getLocationOnScreen(location); // 获取视图在屏幕上的位置
+        int x = location[0];
+        int y = location[1];
+        // 如果触摸事件的x或y坐标超出视图的范围
+        if (ev.getX() < x
+                || ev.getX() > (x + view.getWidth())
+                || ev.getY() < y
+                || ev.getY() > (y + view.getHeight())) {
+            return false; // 不在范围内
+        }
+        return true; // 在范围内
+    }
+
+    /**
+     * 初始化资源，包括视图和监听器。
+     */
+    private void initResources() {
+        mHeadViewPanel = findViewById(R.id.note_title); // 获取笔记标题面板
+        mNoteHeaderHolder = new HeadViewHolder(); // 创建头部视图持有者
+        mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date); // 获取修改日期TextView
+        mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon); // 获取提醒图标ImageView
+        mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date); // 获取提醒日期TextView
+        mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color); // 获取设置背景颜色的ImageView
+        mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this); // 设置点击监听器
+        mNoteEditor = (EditText) findViewById(R.id.note_edit_view); // 获取笔记编辑器
+        mNoteEditorPanel = findViewById(R.id.sv_note_edit); // 获取笔记编辑器面板
+        mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector); // 获取背景颜色选择器
+        for (int id : sBgSelectorBtnsMap.keySet()) {
+            ImageView iv = (ImageView) findViewById(id); // 获取背景颜色按钮
+            iv.setOnClickListener(this); // 设置点击监听器
+        }
+
+        mFontSizeSelector = findViewById(R.id.font_size_selector); // 获取字体大小选择器
+        for (int id : sFontSizeBtnsMap.keySet()) {
+            View view = findViewById(id); // 获取字体大小按钮
+            view.setOnClickListener(this); // 设置点击监听器
+        };
+        mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this); // 获取SharedPreferences对象
+        mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE); // 获取字体大小ID
+        // 如果字体大小ID超出范围，则设置为默认值
+        if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
+            mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
+        }
+        mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list); // 获取编辑文本列表
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause(); // 调用父类的onPause方法
+        if(saveNote()) { // 保存笔记
+            Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length()); // 日志输出保存的笔记长度
+        }
+        clearSettingState(); // 清除设置状态
+    }
+
+    /**
+     * 更新小部件。
+     */
+    private void updateWidget() {
+        Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE); // 创建更新小部件的Intent
+        if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
+            intent.setClass(this, NoteWidgetProvider_2x.class); // 设置小部件提供者类
+        } else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
+            intent.setClass(this, NoteWidgetProvider_4x.class); // 设置小部件提供者类
+        } else {
+            Log.e(TAG, "Unspported widget type"); // 日志输出不支持的小部件类型
+            return;
+        }
+
+        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] { // 添加小部件ID
+                mWorkingNote.getWidgetId()
+        });
+
+        sendBroadcast(intent); // 发送广播
+        setResult(RESULT_OK, intent); // 设置结果
+    }
+
+    @Override
+    public void onClick(View v) {
+        int id = v.getId(); // 获取点击的视图ID
+        if (id == R.id.btn_set_bg_color) {
+            mNoteBgColorSelector.setVisibility(View.VISIBLE); // 显示背景颜色选择器
+            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(-View.VISIBLE); // 显示当前选中的背景颜色
+        } else if (sBgSelectorBtnsMap.containsKey(id)) {
+            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.GONE); // 隐藏当前选中的背景颜色
+            mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id)); // 设置新的背景颜色ID
+            mNoteBgColorSelector.setVisibility(View.GONE); // 隐藏背景颜色选择器
+        } else if (sFontSizeBtnsMap.containsKey(id)) {
+            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE); // 隐藏当前选中的字体大小
+            mFontSizeId = sFontSizeBtnsMap.get(id); // 设置新的字体大小ID
+            mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit(); // 保存字体大小ID到SharedPreferences
+            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE); // 显示新的字体大小
+            if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+                getWorkingText(); // 获取工作文本
+                switchToListMode(mWorkingNote.getContent()); // 切换到列表模式
+            } else {
+                mNoteEditor.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId)); // 设置笔记编辑器的文本样式
+            }
+            mFontSizeSelector.setVisibility(View.GONE); // 隐藏字体大小选择器
+        }
+    }
+
+    @Override
+    public void onBackPressed() {
+        // 当用户按下返回键时，如果设置了清除设置状态并返回true，则直接返回
+        if (clearSettingState()) {
+            return;
+        }
+
+        // 保存笔记
+        saveNote();
+        // 调用父类的onBackPressed方法，完成返回操作
+        super.onBackPressed();
+    }
+
+    /**
+     * 清除设置状态，如背景颜色选择器和字体大小选择器的可见状态。
+     * @return 如果设置了可见状态为不可见，则返回true。
+     */
+    private boolean clearSettingState() {
+        // 如果背景颜色选择器可见，则隐藏并返回true
+        if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
+            mNoteBgColorSelector.setVisibility(View.GONE);
+            return true;
+        } else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
+            // 如果字体大小选择器可见，则隐藏并返回true
+            mFontSizeSelector.setVisibility(View.GONE);
+            return true;
+        }
+        return false; // 没有设置可见状态为不可见，返回false
+    }
+
+    /**
+     * 当背景颜色改变时，更新界面元素的背景。
+     */
+    public void onBackgroundColorChanged() {
+        // 显示当前选中的背景颜色
+        findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(View.VISIBLE);
+        // 设置笔记编辑器面板的背景资源ID
+        mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
+        // 设置笔记标题面板的背景资源ID
+        mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        // 如果活动正在结束，则返回true
+        if (isFinishing()) {
+            return true;
+        }
+        // 清除设置状态
+        clearSettingState();
+        // 清除菜单项
+        menu.clear();
+        // 根据笔记所在的文件夹ID，决定加载哪个菜单
+        if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
+            getMenuInflater().inflate(R.menu.call_note_edit, menu);
+        } else {
+            getMenuInflater().inflate(R.menu.note_edit, menu);
+        }
+        // 根据笔记是否为列表模式，设置菜单项的标题
+        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+            menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode);
+        } else {
+            menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode);
+        }
+        // 如果笔记有闹钟提醒，则隐藏设置提醒的菜单项
+        if (mWorkingNote.hasClockAlert()) {
+            menu.findItem(R.id.menu_alert).setVisible(false);
+        } else {
+            menu.findItem(R.id.menu_delete_remind).setVisible(false);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // 根据点击的菜单项ID，执行相应的操作
+        switch (item.getItemId()) {
+            case R.id.menu_new_note:
+                // 创建新笔记
+                createNewNote();
+                break;
+            case R.id.menu_delete:
+                // 显示删除笔记的对话框
+                AlertDialog.Builder builder = new AlertDialog.Builder(this);
+                builder.setTitle(getString(R.string.alert_title_delete));
+                builder.setIcon(android.R.drawable.ic_dialog_alert);
+                builder.setMessage(getString(R.string.alert_message_delete_note));
+                builder.setPositiveButton(android.R.string.ok,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, int which) {
+                                // 删除当前笔记并结束活动
+                                deleteCurrentNote();
+                                finish();
+                            }
+                        });
+                builder.setNegativeButton(android.R.string.cancel, null);
+                builder.show();
+                break;
+            case R.id.menu_font_size:
+                // 显示字体大小选择器
+                mFontSizeSelector.setVisibility(View.VISIBLE);
+                findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
+                break;
+            case R.id.menu_list_mode:
+                // 切换笔记的列表模式
+                mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
+                        TextNote.MODE_CHECK_LIST : 0);
+                break;
+            case R.id.menu_share:
+                // 分享笔记内容
+                getWorkingText();
+                sendTo(this, mWorkingNote.getContent());
+                break;
+            case R.id.menu_send_to_desktop:
+                // 发送到桌面
+                sendToDesktop();
+                break;
+            case R.id.menu_alert:
+                // 设置提醒
+                setReminder();
+                break;
+            case R.id.menu_delete_remind:
+                // 删除提醒
+                mWorkingNote.setAlertDate(0, false);
+                break;
+            default:
+                break;
+        }
+        return true;
+    }
+
+    /**
+     * 设置提醒，弹出日期时间选择对话框。
+     */
+    private void setReminder() {
+        DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
+        d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
+            public void OnDateTimeSet(AlertDialog dialog, long date) {
+                // 设置提醒日期
+                mWorkingNote.setAlertDate(date, true);
+            }
+        });
+        d.show();
+    }
+
+    /**
+     * 分享笔记内容到支持分享的应用。
+     * @param context 上下文
+     * @param info 要分享的信息
+     */
+    private void sendTo(Context context, String info) {
+        Intent intent = new Intent(Intent.ACTION_SEND);
+        intent.putExtra(Intent.EXTRA_TEXT, info);
+        intent.setType("text/plain");
+        context.startActivity(intent);
+    }
+
+    /**
+     * 创建新笔记。
+     */
+    private void createNewNote() {
+        // 首先，保存当前编辑的笔记
+        saveNote();
+        // 安全起见，结束当前活动并启动一个新的NoteEditActivity
+        finish();
+        Intent intent = new Intent(this, NoteEditActivity.class);
+        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+        intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId());
+        startActivity(intent);
+    }
+
+    /**
+     * 删除当前笔记。
+     */
+    private void deleteCurrentNote() {
+        if (mWorkingNote.existInDatabase()) {
+            HashSet<Long> ids = new HashSet<Long>();
+            long id = mWorkingNote.getNoteId();
+            if (id != Notes.ID_ROOT_FOLDER) {
+                ids.add(id);
+            } else {
+                Log.d(TAG, "Wrong note id, should not happen");
+            }
+            if (!isSyncMode()) {
+                // 如果不是同步模式，则删除笔记
+                if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
+                    Log.e(TAG, "Delete Note error");
+                }
+            } else {
+                // 如果是同步模式，则将笔记移动到垃圾文件夹
+                if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
+                    Log.e(TAG, "Move notes to trash folder error, should not happens");
+                }
+            }
+        }
+        mWorkingNote.markDeleted(true);
+    }
+
+    /**
+     * 检查应用是否处于同步模式。
+     * @return 如果同步账户名不为空，则返回true，表示应用处于同步模式。
+     */
+    private boolean isSyncMode() {
+        return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
+    }
+
+    /**
+     * 当闹钟提醒时间发生变化时调用。
+     * @param date 提醒的时间戳。
+     * @param set 是否设置了提醒。
+     */
+    public void onClockAlertChanged(long date, boolean set) {
+        // 如果笔记尚未保存，则先保存笔记
+        if (!mWorkingNote.existInDatabase()) {
+            saveNote();
+        }
+        // 如果笔记有有效的ID，则继续设置提醒
+        if (mWorkingNote.getNoteId() > 0) {
+            Intent intent = new Intent(this, AlarmReceiver.class);
+            intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
+            PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
+            AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
+            showAlertHeader(); // 更新提醒头部视图
+            // 如果没有设置提醒，则取消闹钟
+            if (!set) {
+                alarmManager.cancel(pendingIntent);
+            } else {
+                // 设置闹钟提醒
+                alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent);
+            }
+        } else {
+            // 如果笔记没有有效的ID，说明用户没有输入任何内容，提醒用户输入内容
+            Log.e(TAG, "Clock alert setting error");
+            showToast(R.string.error_note_empty_for_clock);
+        }
+    }
+
+    /**
+     * 当小部件变化时调用。
+     */
+    public void onWidgetChanged() {
+        updateWidget(); // 更新小部件
+    }
+
+    /**
+     * 当编辑文本被删除时调用。
+     * @param index 被删除文本的索引。
+     * @param text 被删除的文本。
+     */
+    public void onEditTextDelete(int index, String text) {
+        int childCount = mEditTextList.getChildCount();
+        // 如果列表中只有一个子项，则不进行任何操作
+        if (childCount == 1) {
+            return;
+        }
+
+        // 更新后续项的索引
+        for (int i = index + 1; i < childCount; i++) {
+            ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
+                    .setIndex(i - 1);
+        }
+
+        // 从列表中移除指定索引的视图
+        mEditTextList.removeViewAt(index);
+        // 获取前一个或当前第一个编辑框，并追加被删除的文本
+        NoteEditText edit = null;
+        if (index == 0) {
+            edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(R.id.et_edit_text);
+        } else {
+            edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(R.id.et_edit_text);
+        }
+        int length = edit.length();
+        edit.append(text);
+        edit.requestFocus();
+        edit.setSelection(length);
+    }
+
+    /**
+     * 当编辑文本按下回车键时调用。
+     * @param index 当前文本的索引。
+     * @param text 当前文本的内容。
+     */
+    public void onEditTextEnter(int index, String text) {
+        // 检查索引是否超出列表范围，如果超出，记录错误日志
+        if (index > mEditTextList.getChildCount()) {
+            Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
+        }
+
+        // 获取新列表项视图，并添加到编辑文本列表中
+        View view = getListItem(text, index);
+        mEditTextList.addView(view, index);
+        NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
+        edit.requestFocus();
+        edit.setSelection(0);
+        // 更新后续项的索引
+        for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
+            ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
+                    .setIndex(i);
+        }
+    }
+
+    /**
+     * 切换到列表模式，将文本分割成行并显示为列表项。
+     * @param text 要显示的文本。
+     */
+    private void switchToListMode(String text) {
+        mEditTextList.removeAllViews(); // 移除所有列表项
+        String[] items = text.split("\n"); // 按行分割文本
+        int index = 0;
+        for (String item : items) {
+            if(!TextUtils.isEmpty(item)) {
+                mEditTextList.addView(getListItem(item, index)); // 添加非空列表项
+                index++;
+            }
+        }
+        mEditTextList.addView(getListItem("", index)); // 添加一个新的空列表项
+        mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus(); // 请求焦点
+
+        mNoteEditor.setVisibility(View.GONE); // 隐藏笔记编辑器
+        mEditTextList.setVisibility(View.VISIBLE); // 显示编辑文本列表
+    }
+
+    /**
+     * 获取高亮查询结果的Spannable对象。
+     * @param fullText 全文文本。
+     * @param userQuery 用户查询字符串。
+     * @return 高亮查询结果的Spannable对象。
+     */
+    private Spannable getHighlightQueryResult(String fullText, String userQuery) {
+        SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
+        if (!TextUtils.isEmpty(userQuery)) {
+            mPattern = Pattern.compile(userQuery); // 编译查询模式
+            Matcher m = mPattern.matcher(fullText); // 匹配查询模式
+            int start = 0;
+            while (m.find(start)) {
+                spannable.setSpan(
+                        new BackgroundColorSpan(this.getResources().getColor(
+                                R.color.user_query_highlight)), m.start(), m.end(),
+                        Spannable.SPAN_INCLUSIVE_EXCLUSIVE); // 设置高亮背景
+                start = m.end();
+            }
+        }
+        return spannable;
+    }
+
+    /**
+     * 获取列表项视图。
+     * @param item 列表项文本。
+     * @param index 列表项索引。
+     * @return 列表项视图。
+     */
+    private View getListItem(String item, int index) {
+        View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
+        final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
+        edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
+        CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
+        cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
+            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+                if (isChecked) {
+                    edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG); // 勾选时设置删除线
+                } else {
+                    edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG); // 未勾选时重置
+                }
+            }
+        });
+
+        // 设置复选框状态和编辑框文本
+        if (item.startsWith(TAG_CHECKED)) {
+            cb.setChecked(true);
+            edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
+            item = item.substring(TAG_CHECKED.length(), item.length()).trim();
+        } else if (item.startsWith(TAG_UNCHECKED)) {
+            cb.setChecked(false);
+            edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
+            item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
+        }
+
+        edit.setOnTextViewChangeListener(this);
+        edit.setIndex(index);
+        edit.setText(getHighlightQueryResult(item, mUserQuery));
+        return view;
+    }
+
+    /**
+     * 当文本变化时调用。
+     * @param index 文本索引。
+     * @param hasText 是否有文本。
+     */
+    public void onTextChange(int index, boolean hasText) {
+        if (index >= mEditTextList.getChildCount()) {
+            Log.e(TAG, "Wrong index, should not happen");
+            return;
+        }
+        if (hasText) {
+            mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
+        } else {
+            mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
+        }
+    }
+
+    /**
+     * 当列表模式改变时调用。
+     * @param oldMode 旧模式。
+     * @param newMode 新模式。
+     */
+    public void onCheckListModeChanged(int oldMode, int newMode) {
+        if (newMode == TextNote.MODE_CHECK_LIST) {
+            switchToListMode(mNoteEditor.getText().toString());
+        } else {
+            if (!getWorkingText()) {
+                mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
+                        ""));
+            }
+            mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
+            mEditTextList.setVisibility(View.GONE);
+            mNoteEditor.setVisibility(View.VISIBLE);
+        }
+    }
+
+    /**
+     * 获取工作文本，即从列表模式中获取文本。
+     * @return 如果有勾选项，则返回true。
+     */
+    private boolean getWorkingText() {
+        boolean hasChecked = false;
+        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < mEditTextList.getChildCount(); i++) {
+                View view = mEditTextList.getChildAt(i);
+                NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
+                if (!TextUtils.isEmpty(edit.getText())) {
+                    if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
+                        sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
+                        hasChecked = true;
+                    } else {
+                        sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
+                    }
+                }
+            }
+            mWorkingNote.setWorkingText(sb.toString());
+        } else {
+            mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
+        }
+        return hasChecked;
+    }
+    /**
+     * 保存当前笔记到数据库。
+     * @return 如果笔记保存成功，返回true；否则返回false。
+     */
+    private boolean saveNote() {
+        // 获取工作文本，可能是从列表模式转换来的文本
+        getWorkingText();
+        // 调用mWorkingNote对象的saveNote方法保存笔记，并接收返回值
+        boolean saved = mWorkingNote.saveNote();
+        // 如果保存成功，设置activity的结果码为RESULT_OK，用于标识创建或编辑状态
+        if (saved) {
+            setResult(RESULT_OK);
+        }
+        return saved; // 返回保存结果
+    }
+
+    /**
+     * 将当前编辑的笔记发送到桌面作为快捷方式。
+     */
+    private void sendToDesktop() {
+        // 如果当前笔记不在数据库中（即新笔记），则先保存笔记
+        if (!mWorkingNote.existInDatabase()) {
+            saveNote();
+        }
+
+        // 如果笔记有有效的ID，说明笔记已保存，可以创建快捷方式
+        if (mWorkingNote.getNoteId() > 0) {
+            Intent sender = new Intent(); // 创建Intent对象
+            Intent shortcutIntent = new Intent(this, NoteEditActivity.class); // 创建快捷方式的Intent
+            shortcutIntent.setAction(Intent.ACTION_VIEW); // 设置动作为查看
+            shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId()); // 附加笔记ID
+            sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent); // 附加快捷方式Intent
+            sender.putExtra(Intent.EXTRA_SHORTCUT_NAME, makeShortcutIconTitle(mWorkingNote.getContent())); // 附加快捷方式名称
+            sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app)); // 附加快捷方式图标
+            sender.putExtra("duplicate", true); // 允许重复创建快捷方式
+            sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT"); // 设置动作为安装快捷方式
+            showToast(R.string.info_note_enter_desktop); // 显示提示信息
+            sendBroadcast(sender); // 发送广播创建快捷方式
+        } else {
+            // 如果笔记没有有效的ID，说明笔记未保存，记录错误日志并提示用户输入内容
+            Log.e(TAG, "Send to desktop error");
+            showToast(R.string.error_note_empty_for_send_to_desktop);
+        }
+    }
+
+    /**
+     * 生成快捷方式图标的标题，使用笔记内容的前一部分作为标题。
+     * @param content 笔记内容。
+     * @return 快捷方式图标的标题。
+     */
+    private String makeShortcutIconTitle(String content) {
+        content = content.replace(TAG_CHECKED, ""); // 移除TAG_CHECKED标记
+        content = content.replace(TAG_UNCHECKED, ""); // 移除TAG_UNCHECKED标记
+        // 如果内容长度超过最大长度，截取前一部分作为标题
+        return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0, SHORTCUT_ICON_TITLE_MAX_LEN) : content;
+    }
+
+    /**
+     * 显示短提示信息。
+     * @param resId 资源ID。
+     */
+    private void showToast(int resId) {
+        showToast(resId, Toast.LENGTH_SHORT); // 调用重载方法显示提示信息
+    }
+
+    /**
+     * 显示提示信息。
+     * @param resId 资源ID。
+     * @param duration 显示时长。
+     */
+    private void showToast(int resId, int duration) {
+        Toast.makeText(this, resId, duration).show(); // 显示提示信息
+    }

ui/NoteEditText.java

@@ -0,0 +1,236 @@
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.text.Layout;
+import android.text.Selection;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.style.URLSpan;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.widget.EditText;
+
+import net.micode.notes.R;
+
+import java.util.HashMap;
+import java.util.Map;
+
+// 定义了一个名为NoteEditText的类，它继承自Android SDK中的EditText类，用于自定义笔记编辑文本框。
+public class NoteEditText extends EditText {
+    // 类的成员变量，用于日志标记。
+    private static final String TAG = "NoteEditText";
+
+    // 索引变量，用于跟踪当前编辑的文本位置。
+    private int mIndex;
+
+    // 记录删除操作前光标的位置，用于处理删除操作。
+    private int mSelectionStartBeforeDelete;
+
+    // 定义几种常见的URL协议，用于识别电话、http链接和邮件。
+    private static final String SCHEME_TEL = "tel:" ;
+    private static final String SCHEME_HTTP = "http:" ;
+    private static final String SCHEME_EMAIL = "mailto:" ;
+
+    // 一个映射，将不同的URL协议映射到对应的字符串资源，用于上下文菜单中显示。
+    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
+    static {
+        // 静态代码块，在类加载时执行，初始化映射关系。
+        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
+        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
+        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
+    }
+
+    // 定义一个内部接口，用于监听文本编辑的变化。
+    public interface OnTextViewChangeListener {
+        // 当删除键被按下且文本为空时调用。
+        void onEditTextDelete(int index, String text);
+        // 当回车键被按下时调用。
+        void onEditTextEnter(int index, String text);
+        // 当文本发生变化时调用。
+        void onTextChange(int index, boolean hasText);
+    }
+
+    // 接口的实例，用于回调文本编辑的变化。
+    private OnTextViewChangeListener mOnTextViewChangeListener;
+
+    // NoteEditText的构造函数，只接收一个Context参数。
+    public NoteEditText(Context context) {
+        super(context, null);
+        mIndex = 0;
+    }
+
+    // 设置当前编辑文本的索引。
+    public void setIndex(int index) {
+        mIndex = index;
+    }
+
+    // 设置文本编辑变化的监听器。
+    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
+        mOnTextViewChangeListener = listener;
+    }
+
+    // NoteEditText的构造函数，接收Context和AttributeSet参数。
+    public NoteEditText(Context context, AttributeSet attrs) {
+        super(context, attrs, android.R.attr.editTextStyle);
+    }
+
+    // NoteEditText的构造函数，接收Context、AttributeSet和defStyle参数。
+    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        // 这里有一个TODO注释，提示这里是一个自动生成的构造函数体，可能需要根据需要进行修改。
+        // TODO Auto-generated constructor stub
+    }
+
+    // 重写onTouchEvent方法，处理触摸事件，主要用于移动光标位置。
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                // 计算触摸点的位置，并将其转换为文本中的偏移量。
+                int x = (int) event.getX();
+                int y = (int) event.getY();
+                x -= getTotalPaddingLeft();
+                y -= getTotalPaddingTop();
+                x += getScrollX();
+                y += getScrollY();
+
+                Layout layout = getLayout();
+                int line = layout.getLineForVertical(y);
+                int off = layout.getOffsetForHorizontal(line, x);
+                Selection.setSelection(getText(), off);
+                break;
+        }
+
+        return super.onTouchEvent(event);
+    }
+
+    // 重写onKeyDown方法，处理按键按下事件，特别是回车和删除键。
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_ENTER:
+                // 如果设置了监听器，消费回车键事件。
+                if (mOnTextViewChangeListener != null) {
+                    return false;
+                }
+                break;
+            case KeyEvent.KEYCODE_DEL:
+                // 记录删除前光标的位置。
+                mSelectionStartBeforeDelete = getSelectionStart();
+                break;
+            default:
+                break;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    // 重写onKeyUp方法，处理按键释放事件，特别是删除和回车键。
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        switch(keyCode) {
+            case KeyEvent.KEYCODE_DEL:
+                // 如果设置了监听器，且光标在最开始位置，则触发删除事件。
+                if (mOnTextViewChangeListener != null) {
+                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
+                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
+                        return true;
+                    }
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            case KeyEvent.KEYCODE_ENTER:
+                // 如果设置了监听器，触发回车事件。
+                if (mOnTextViewChangeListener != null) {
+                    int selectionStart = getSelectionStart();
+                    String text = getText().subSequence(selectionStart, length()).toString();
+                    setText(getText().subSequence(0, selectionStart));
+                    mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
+                } else {
+                    Log.d(TAG, "OnTextViewChangeListener was not seted");
+                }
+                break;
+            default:
+                break;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    // 重写onFocusChanged方法，处理焦点变化事件，用于更新文本变化。
+    @Override
+    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+        if (mOnTextViewChangeListener != null) {
+            if (!focused && TextUtils.isEmpty(getText())) {
+                // 如果焦点失去并且文本为空，通知监听器没有文本。
+                mOnTextViewChangeListener.onTextChange(mIndex, false);
+            } else {
+                // 如果焦点变化，通知监听器文本变化。
+                mOnTextViewChangeListener.onTextChange(mIndex, true);
+            }
+        }
+        super.onFocusChanged(focused, direction, previouslyFocusedRect);
+    }
+
+    // 重写onCreateContextMenu方法，创建上下文菜单，特别是处理URL链接。
+    @Override
+    protected void onCreateContextMenu(ContextMenu menu) {
+        if (getText() instanceof Spanned) {
+            int selStart = getSelectionStart();
+            int selEnd = getSelectionEnd();
+
+            int min = Math.min(selStart, selEnd);
+            int max = Math.max(selStart, selEnd);
+
+            // 获取选中的URLSpan对象。
+            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
+            if (urls.length == 1) {
+                int defaultResId = 0;
+                for(String schema: sSchemaActionResMap.keySet()) {
+                    // 根据URL协议找到对应的字符串资源。
+                    if(urls[0].getURL().indexOf(schema) >= 0) {
+                        defaultResId = sSchemaActionResMap.get(schema);
+                        break;
+                    }
+                }
+
+                if (defaultResId == 0) {
+                    // 如果没有找到对应的协议，使用默认的字符串资源。
+                    defaultResId = R.string.note_link_other;
+                }
+
+                // 添加上下文菜单项，并设置点击事件。
+                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+                        new OnMenuItemClickListener() {
+                            public boolean onMenuItemClick(MenuItem item) {
+                                // 点击时，执行URLSpan的onClick事件。
+                                urls[0].onClick(NoteEditText.this);
+                                return true;
+                            }
+                        });
+            }
+        }
+        super.onCreateContextMenu(menu);
+    }
+}

ui/NoteItemData.java

@@ -0,0 +1,346 @@
+/**
+ * 版权声明，说明该代码是由MiCode开源社区编写，并在Apache License 2.0下授权。
+ * 该许可证允许用户在遵守条款的前提下使用、复制、分发和修改该文件。
+ */
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.text.TextUtils;
+
+import net.micode.notes.data.Contact;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.tool.DataUtils;
+
+/**
+ * NoteItemData类用于封装从数据库查询到的笔记项数据。
+ */
+public class NoteItemData {
+    // 数据库查询时需要的列名数组
+    static final String [] PROJECTION = new String [] {
+            NoteColumns.ID, // 笔记项ID
+            NoteColumns.ALERTED_DATE, // 笔记项提醒日期
+            NoteColumns.BG_COLOR_ID, // 笔记项背景色ID
+            NoteColumns.CREATED_DATE, // 笔记项创建日期
+            NoteColumns.HAS_ATTACHMENT, // 笔记项是否有附件
+            NoteColumns.MODIFIED_DATE, // 笔记项修改日期
+            NoteColumns.NOTES_COUNT, // 笔记项中的笔记数量
+            NoteColumns.PARENT_ID, // 笔记项的父ID，通常指向文件夹
+            NoteColumns.SNIPPET, // 笔记项的摘要
+            NoteColumns.TYPE, // 笔记项类型
+            NoteColumns.WIDGET_ID, // 笔记项关联的Widget ID
+            NoteColumns.WIDGET_TYPE, // 笔记项关联的Widget类型
+    };
+
+    // 列索引，用于快速访问游标中的数据
+    private static final int ID_COLUMN                    = 0;
+    private static final int ALERTED_DATE_COLUMN          = 1;
+    private static final int BG_COLOR_ID_COLUMN           = 2;
+    private static final int CREATED_DATE_COLUMN          = 3;
+    private static final int HAS_ATTACHMENT_COLUMN        = 4;
+    private static final int MODIFIED_DATE_COLUMN         = 5;
+    private static final int NOTES_COUNT_COLUMN           = 6;
+    private static final int PARENT_ID_COLUMN             = 7;
+    private static final int SNIPPET_COLUMN               = 8;
+    private static final int TYPE_COLUMN                  = 9;
+    private static final int WIDGET_ID_COLUMN             = 10;
+    private static final int WIDGET_TYPE_COLUMN           = 11;
+
+    // 笔记项的属性，与PROJECTION数组中的列对应
+    private long mId; // 笔记项ID
+    private long mAlertDate; // 笔记项提醒日期
+    private int mBgColorId; // 笔记项背景色ID
+    private long mCreatedDate; // 笔记项创建日期
+    private boolean mHasAttachment; // 笔记项是否有附件
+    private long mModifiedDate; // 笔记项修改日期
+    private int mNotesCount; // 笔记项中的笔记数量
+    private long mParentId; // 笔记项的父ID
+    private String mSnippet; // 笔记项的摘要
+    private int mType; // 笔记项类型
+    private int mWidgetId; // 笔记项关联的Widget ID
+    private int mWidgetType; // 笔记项关联的Widget类型
+    private String mName; // 与笔记项关联的联系人姓名
+    private String mPhoneNumber; // 与笔记项关联的电话号码
+
+    // 用于标记笔记项在列表中的位置
+    private boolean mIsLastItem; // 是否是最后一项
+    private boolean mIsFirstItem; // 是否是第一项
+    private boolean mIsOnlyOneItem; // 是否仅有一个笔记项
+    private boolean mIsOneNoteFollowingFolder; // 是否有一个笔记项跟在文件夹后面
+    private boolean mIsMultiNotesFollowingFolder; // 是否有多个笔记项跟在文件夹后面
+
+    /**
+     * 构造函数，从Cursor中获取数据并初始化NoteItemData对象。
+     * @param context 上下文对象，用于访问应用程序的资源和类
+     * @param cursor 数据库查询结果的游标，包含笔记项的数据
+     */
+    public NoteItemData(Context context, Cursor cursor) {
+        // 从游标中获取笔记项的数据，并赋值给对应的成员变量
+        mId = cursor.getLong(ID_COLUMN);
+        mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
+        mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
+        mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
+        // 检查是否有附件，根据游标中的数据设置mHasAttachment的值
+        mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false;
+        mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
+        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
+        mParentId = cursor.getLong(PARENT_ID_COLUMN);
+        // 获取摘要，并移除特定的标签
+        mSnippet = cursor.getString(SNIPPET_COLUMN);
+        mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
+                NoteEditActivity.TAG_UNCHECKED, "");
+        mType = cursor.getInt(TYPE_COLUMN);
+        mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
+        mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
+
+        // 如果笔记项的父ID是通话记录文件夹的ID，则尝试获取关联的电话号码和联系人姓名
+        mPhoneNumber = "";
+        if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
+            mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
+            if (!TextUtils.isEmpty(mPhoneNumber)) {
+                mName = Contact.getContact(context, mPhoneNumber);
+                // 如果没有找到联系人姓名，则使用电话号码作为姓名
+                if (mName == null) {
+                    mName = mPhoneNumber;
+                }
+            }
+        }
+
+        // 如果没有找到联系人姓名，则设置为空字符串
+        if (mName == null) {
+            mName = "";
+        }
+        // 检查笔记项在游标中的位置，并设置位置标记
+        checkPostion(cursor);
+    }
+
+    /**
+     * 检查笔记项在游标中的位置，并设置相应的标记。
+     * @param cursor 数据库查询结果的游标
+     */
+    private void checkPostion(Cursor cursor) {
+        // 设置是否是最后一项、第一项和仅有一个笔记项的标记
+        mIsLastItem = cursor.isLast() ? true : false;
+        mIsFirstItem = cursor.isFirst() ? true : false;
+        mIsOnlyOneItem = (cursor.getCount() == 1);
+        mIsMultiNotesFollowingFolder = false;
+        mIsOneNoteFollowingFolder = false;
+
+        // 如果笔记项类型是笔记并且不是第一项，则检查是否有笔记项跟在文件夹后面
+        if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
+            int position = cursor.getPosition();
+            if (cursor.moveToPrevious()) {
+                // 如果前一项是文件夹或系统项，则检查后面是否有多个笔记项
+                if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
+                        || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
+                    if (cursor.getCount() > (position + 1)) {
+                        mIsMultiNotesFollowingFolder = true;
+                    } else {
+                        mIsOneNoteFollowingFolder = true;
+                    }
+                }
+                // 将游标移回原来的位置
+                if (!cursor.moveToNext()) {
+                    throw new IllegalStateException("cursor move to previous but can't move back");
+                }
+            }
+        }
+    }
+
+    // 下面是一系列getter方法，用于获取笔记项的属性值。
+
+    /**
+     * 判断是否有一个笔记项跟在文件夹后面。
+     * @return 如果有一个笔记项跟在文件夹后面，则返回true；否则返回false。
+     */
+    public boolean isOneFollowingFolder() {
+        return mIsOneNoteFollowingFolder;
+    }
+
+    /**
+     * 判断是否有多个笔记项跟在文件夹后面。
+     * @return 如果有多个笔记项跟在文件夹后面，则返回true；否则返回false。
+     */
+    public boolean isMultiFollowingFolder() {
+        return mIsMultiNotesFollowingFolder;
+    }
+
+    /**
+     * 判断是否是最后一项。
+     * @return 如果是最后一项，则返回true；否则返回false。
+     */
+    public boolean isLast() {
+        return mIsLastItem;
+    }
+
+    /**
+     * 获取与笔记项关联的联系人姓名。
+     * @return 返回联系人姓名，如果没有找到则返回空字符串。
+     */
+    public String getCallName() {
+        return mName;
+    }
+
+    /**
+     * 判断是否是第一项。
+     * @return 如果是第一项，则返回true；否则返回false。
+     */
+    public boolean isFirst() {
+        return mIsFirstItem;
+    }
+
+    /**
+     * 判断笔记项是否是单个项目。
+     * @return 如果是单个项目，则返回true；否则返回false。
+     */
+    public boolean isSingle() {
+        return mIsOnlyOneItem;
+    }
+
+    /**
+     * 获取笔记项的ID。
+     * @return 返回笔记项的ID。
+     */
+    public long getId() {
+        return mId;
+    }
+
+    /**
+     * 获取笔记项的提醒日期。
+     * @return 返回笔记项的提醒日期。
+     */
+    public long getAlertDate() {
+        return mAlertDate;
+    }
+
+    /**
+     * 获取笔记项的创建日期。
+     * @return 返回笔记项的创建日期。
+     */
+    public long getCreatedDate() {
+        return mCreatedDate;
+    }
+
+    /**
+     * 判断笔记项是否有附件。
+     * @return 如果有附件，则返回true；否则返回false。
+     */
+    public boolean hasAttachment() {
+        return mHasAttachment;
+    }
+
+    /**
+     * 获取笔记项的修改日期。
+     * @return 返回笔记项的修改日期。
+     */
+    public long getModifiedDate() {
+        return mModifiedDate;
+    }
+
+    /**
+     * 获取笔记项的背景色ID。
+     * @return 返回笔记项的背景色ID。
+     */
+    public int getBgColorId() {
+        return mBgColorId;
+    }
+
+    /**
+     * 获取笔记项的父ID，通常指向文件夹。
+     * @return 返回笔记项的父ID。
+     */
+    public long getParentId() {
+        return mParentId;
+    }
+
+    /**
+     * 获取笔记项中的笔记数量。
+     * @return 返回笔记项中的笔记数量。
+     */
+    public int getNotesCount() {
+        return mNotesCount;
+    }
+
+    /**
+     * 获取笔记项的文件夹ID。
+     * 由于笔记项的父ID通常指向文件夹，因此这里返回父ID。
+     * @return 返回笔记项的文件夹ID。
+     */
+    public long getFolderId() {
+        return mParentId;
+    }
+
+    /**
+     * 获取笔记项的类型。
+     * @return 返回笔记项的类型。
+     */
+    public int getType() {
+        return mType;
+    }
+
+    /**
+     * 获取笔记项关联的Widget类型。
+     * @return 返回笔记项关联的Widget类型。
+     */
+    public int getWidgetType() {
+        return mWidgetType;
+    }
+
+    /**
+     * 获取笔记项关联的Widget ID。
+     * @return 返回笔记项关联的Widget ID。
+     */
+    public int getWidgetId() {
+        return mWidgetId;
+    }
+
+    /**
+     * 获取笔记项的摘要。
+     * @return 返回笔记项的摘要。
+     */
+    public String getSnippet() {
+        return mSnippet;
+    }
+
+    /**
+     * 判断笔记项是否有提醒。
+     * @return 如果有提醒，则返回true；否则返回false。
+     */
+    public boolean hasAlert() {
+        return (mAlertDate > 0);
+    }
+
+    /**
+     * 判断笔记项是否是通话记录。
+     * @return 如果是通话记录，则返回true；否则返回false。
+     */
+    public boolean isCallRecord() {
+        return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
+    }
+
+    /**
+     * 从游标中获取笔记项的类型。
+     * @param cursor 数据库查询结果的游标。
+     * @return 返回游标指向的笔记项的类型。
+     */
+    public static int getNoteType(Cursor cursor) {
+        return cursor.getInt(TYPE_COLUMN);
+    }
+}

ui/NotesListAdapter.java

@@ -0,0 +1,198 @@
+/*
+ * 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.ui;
+
+// 导入所需的Android SDK类和包
+import android.content.Context;
+import android.database.Cursor;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+
+// 导入Notes应用特有的数据类
+import net.micode.notes.data.Notes;
+
+// 导入Java的集合框架
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+
+// NotesListAdapter类继承自CursorAdapter，用于显示和管理笔记列表
+public class NotesListAdapter extends CursorAdapter {
+    // 类的成员变量
+    private static final String TAG = "NotesListAdapter"; // 用于日志标记
+    private Context mContext; // 上下文对象，用于访问应用程序的资源和类
+    private HashMap<Integer, Boolean> mSelectedIndex; // 存储每个列表项的选中状态
+    private int mNotesCount; // 笔记数量
+    private boolean mChoiceMode; // 是否处于选择模式
+
+    // AppWidgetAttribute内部类，用于存储应用小部件的属性
+    public static class AppWidgetAttribute {
+        public int widgetId; // 小部件ID
+        public int widgetType; // 小部件类型
+    };
+
+    // 构造函数，初始化适配器
+    public NotesListAdapter(Context context) {
+        super(context, null); // 调用父类的构造函数
+        mSelectedIndex = new HashMap<Integer, Boolean>(); // 初始化选中状态的HashMap
+        mContext = context; // 保存上下文对象
+        mNotesCount = 0; // 初始化笔记数量为0
+    }
+
+    // 新建视图的方法，用于创建新的列表项视图
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return new NotesListItem(context); // 返回一个新的NotesListItem视图
+    }
+
+    // 绑定视图的方法，用于将数据绑定到视图上
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        if (view instanceof NotesListItem) { // 检查视图是否是NotesListItem的实例
+            NoteItemData itemData = new NoteItemData(context, cursor); // 创建NoteItemData对象，包含笔记数据
+            ((NotesListItem) view).bind(context, itemData, mChoiceMode, isSelectedItem(cursor.getPosition())); // 绑定数据到视图
+        }
+    }
+
+    // 设置列表项的选中状态
+    public void setCheckedItem(final int position, final boolean checked) {
+        mSelectedIndex.put(position, checked); // 在HashMap中设置选中状态
+        notifyDataSetChanged(); // 通知数据集改变
+    }
+
+    // 获取是否处于选择模式
+    public boolean isInChoiceMode() {
+        return mChoiceMode;
+    }
+
+    // 设置选择模式
+    public void setChoiceMode(boolean mode) {
+        mSelectedIndex.clear(); // 清空选中状态
+        mChoiceMode = mode; // 设置选择模式
+    }
+
+    // 全选或全不选
+    public void selectAll(boolean checked) {
+        Cursor cursor = getCursor(); // 获取游标
+        for (int i = 0; i < getCount(); i++) { // 遍历所有项
+            if (cursor.moveToPosition(i)) { // 移动游标到当前位置
+                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) { // 如果是笔记类型
+                    setCheckedItem(i, checked); // 设置选中状态
+                }
+            }
+        }
+    }
+
+    // 获取所有选中的笔记ID
+    public HashSet<Long> getSelectedItemIds() {
+        HashSet<Long> itemSet = new HashSet<Long>(); // 存储选中的笔记ID
+        for (Integer position : mSelectedIndex.keySet()) { // 遍历所有选中状态
+            if (mSelectedIndex.get(position) == true) { // 如果是选中的
+                Long id = getItemId(position); // 获取笔记ID
+                if (id != Notes.ID_ROOT_FOLDER) { // 如果ID不是根文件夹ID
+                    itemSet.add(id); // 添加到集合中
+                }
+            }
+        }
+        return itemSet; // 返回集合
+    }
+
+    // 获取所有选中的应用小部件属性
+    public HashSet<AppWidgetAttribute> getSelectedWidget() {
+        HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>(); // 存储选中的小部件属性
+        for (Integer position : mSelectedIndex.keySet()) { // 遍历所有选中状态
+            if (mSelectedIndex.get(position) == true) { // 如果是选中的
+                Cursor c = (Cursor) getItem(position); // 获取游标
+                if (c != null) { // 如果游标不为空
+                    AppWidgetAttribute widget = new AppWidgetAttribute(); // 创建小部件属性对象
+                    NoteItemData item = new NoteItemData(mContext, c); // 创建NoteItemData对象
+                    widget.widgetId = item.getWidgetId(); // 获取小部件ID
+                    widget.widgetType = item.getWidgetType(); // 获取小部件类型
+                    itemSet.add(widget); // 添加到集合中
+                } else {
+                    Log.e(TAG, "Invalid cursor"); // 日志错误
+                    return null; // 返回null
+                }
+            }
+        }
+        return itemSet; // 返回集合
+    }
+
+    // 获取选中的数量
+    public int getSelectedCount() {
+        Collection<Boolean> values = mSelectedIndex.values(); // 获取所有选中状态的值
+        if (null == values) {
+            return 0; // 如果为空，返回0
+        }
+        Iterator<Boolean> iter = values.iterator(); // 创建迭代器
+        int count = 0; // 初始化计数器
+        while (iter.hasNext()) { // 遍历所有值
+            if (true == iter.next()) { // 如果是选中的
+                count++; // 计数器加1
+            }
+        }
+        return count; // 返回计数
+    }
+
+    // 检查是否全部选中
+    public boolean isAllSelected() {
+        int checkedCount = getSelectedCount(); // 获取选中的数量
+        return (checkedCount != 0 && checkedCount == mNotesCount); // 如果选中数量不为0且等于笔记数量，则返回true
+    }
+
+    // 检查某个位置的项是否被选中
+    public boolean isSelectedItem(final int position) {
+        if (null == mSelectedIndex.get(position)) { // 如果HashMap中没有这个位置的值
+            return false; // 返回false
+        }
+        return mSelectedIndex.get(position); // 返回选中状态
+    }
+
+    // 当内容改变时调用的方法
+    @Override
+    protected void onContentChanged() {
+        super.onContentChanged(); // 调用父类的方法
+        calcNotesCount(); // 计算笔记数量
+    }
+
+    // 更改游标时调用的方法
+    @Override
+    public void changeCursor(Cursor cursor) {
+        super.changeCursor(cursor); // 调用父类的方法
+        calcNotesCount(); // 计算笔记数量
+    }
+
+    // 计算笔记数量的方法
+    private void calcNotesCount() {
+        mNotesCount = 0; // 初始化笔记数量为0
+        for (int i = 0; i < getCount(); i++) { // 遍历所有项
+            Cursor c = (Cursor) getItem(i); // 获取游标
+            if (c != null) { // 如果游标不为空
+                if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) { // 如果是笔记类型
+                    mNotesCount++; // 笔记数量加1
+                }
+            } else {
+                Log.e(TAG, "Invalid cursor"); // 日志错误
+                return; // 返回
+            }
+        }
+    }
+}

ui/NotesListItem.java

@@ -0,0 +1,138 @@
+/*
+ * 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.ui;
+
+// 导入所需的Android SDK类和包
+import android.content.Context;
+import android.text.format.DateUtils;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+// 导入Notes应用特有的资源和数据类
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
+
+// NotesListItem类继承自LinearLayout，用于显示单个笔记列表项的视图
+public class NotesListItem extends LinearLayout {
+    // 类的成员变量
+    private ImageView mAlert; // 用于显示提醒图标的ImageView
+    private TextView mTitle; // 显示标题的TextView
+    private TextView mTime; // 显示时间的TextView
+    private TextView mCallName; // 显示来电姓名的TextView
+    private NoteItemData mItemData; // 包含笔记数据的NoteItemData对象
+    private CheckBox mCheckBox; // 用于选择模式的CheckBox
+
+    // 构造函数，初始化视图
+    public NotesListItem(Context context) {
+        super(context); // 调用父类的构造函数
+        inflate(context, R.layout.note_item, this); // 将布局文件inflate到当前视图中
+        mAlert = (ImageView) findViewById(R.id.iv_alert_icon); // 获取布局中的ImageView
+        mTitle = (TextView) findViewById(R.id.tv_title); // 获取布局中的TextView
+        mTime = (TextView) findViewById(R.id.tv_time); // 获取布局中的TextView
+        mCallName = (TextView) findViewById(R.id.tv_name); // 获取布局中的TextView
+        mCheckBox = (CheckBox) findViewById(android.R.id.checkbox); // 获取布局中的CheckBox
+    }
+
+    // bind方法，用于将数据绑定到视图上
+    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
+        // 根据是否处于选择模式和笔记类型，设置CheckBox的可见性和选中状态
+        if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
+            mCheckBox.setVisibility(View.VISIBLE);
+            mCheckBox.setChecked(checked);
+        } else {
+            mCheckBox.setVisibility(View.GONE);
+        }
+
+        mItemData = data; // 保存NoteItemData对象
+        // 根据笔记数据的不同类型，设置不同的视图显示
+        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            // 如果是通话记录文件夹
+            mCallName.setVisibility(View.GONE);
+            mAlert.setVisibility(View.VISIBLE);
+            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
+            mTitle.setText(context.getString(R.string.call_record_folder_name)
+                    + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
+            mAlert.setImageResource(R.drawable.call_record);
+        } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
+            // 如果是通话记录文件夹下的笔记
+            mCallName.setVisibility(View.VISIBLE);
+            mCallName.setText(data.getCallName());
+            mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
+            mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+            if (data.hasAlert()) {
+                mAlert.setImageResource(R.drawable.clock);
+                mAlert.setVisibility(View.VISIBLE);
+            } else {
+                mAlert.setVisibility(View.GONE);
+            }
+        } else {
+            // 其他类型的笔记
+            mCallName.setVisibility(View.GONE);
+            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
+            if (data.getType() == Notes.TYPE_FOLDER) {
+                // 如果是文件夹
+                mTitle.setText(data.getSnippet()
+                        + context.getString(R.string.format_folder_files_count,
+                        data.getNotesCount()));
+                mAlert.setVisibility(View.GONE);
+            } else {
+                // 普通笔记
+                mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+                if (data.hasAlert()) {
+                    mAlert.setImageResource(R.drawable.clock);
+                    mAlert.setVisibility(View.VISIBLE);
+                } else {
+                    mAlert.setVisibility(View.GONE);
+                }
+            }
+        }
+        // 设置时间显示
+        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
+        // 设置背景
+        setBackground(data);
+    }
+
+    // setBackground方法，用于设置视图的背景
+    private void setBackground(NoteItemData data) {
+        int id = data.getBgColorId(); // 获取背景颜色ID
+        // 根据笔记类型和位置设置不同的背景资源
+        if (data.getType() == Notes.TYPE_NOTE) {
+            if (data.isSingle() || data.isOneFollowingFolder()) {
+                setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
+            } else if (data.isLast()) {
+                setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
+            } else if (data.isFirst() || data.isMultiFollowingFolder()) {
+                setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
+            } else {
+                setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
+            }
+        } else {
+            setBackgroundResource(NoteItemBgResources.getFolderBgRes());
+        }
+    }
+
+    // getItemData方法，用于获取当前项的NoteItemData对象
+    public NoteItemData getItemData() {
+        return mItemData;
+    }
+}

ui/NotesPreferenceActivity.java

@@ -0,0 +1,397 @@
+/*
+ * 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.ui;
+
+// 导入所需的Android SDK类和包
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.ActionBar;
+import android.app.AlertDialog;
+import android.content.BroadcastReceiver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+// 导入Notes应用特有的资源和数据类
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.remote.GTaskSyncService;
+
+// NotesPreferenceActivity类继承自PreferenceActivity，用于显示和处理应用的设置界面
+public class NotesPreferenceActivity extends PreferenceActivity {
+    // 类的静态常量
+    public static final String PREFERENCE_NAME = "notes_preferences";
+    public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
+    public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
+    public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
+    private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
+    private static final String AUTHORITIES_FILTER_KEY = "authorities";
+
+    // 类的成员变量
+    private PreferenceCategory mAccountCategory; // 账户设置的PreferenceCategory
+    private GTaskReceiver mReceiver; // 用于接收同步状态广播的BroadcastReceiver
+    private Account[] mOriAccounts; // 原始账户数组
+    private boolean mHasAddedAccount; // 是否添加了账户
+
+    // onCreate方法，Activity创建时调用
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        // 设置ActionBar的返回键
+        getActionBar().setDisplayHomeAsUpEnabled(true);
+
+        // 从XML资源文件中添加偏好设置
+        addPreferencesFromResource(R.xml.preferences);
+        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+        mReceiver = new GTaskReceiver(); // 创建BroadcastReceiver
+        IntentFilter filter = new IntentFilter(); // 创建IntentFilter
+        filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME); // 添加过滤的Action
+        registerReceiver(mReceiver, filter); // 注册BroadcastReceiver
+
+        mOriAccounts = null; // 初始化原始账户数组
+        View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null); // 从XML布局文件中inflate头部视图
+        getListView().addHeaderView(header, null, true); // 将头部视图添加到ListView中
+    }
+
+    // onResume方法，Activity回到前台时调用
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        // 如果用户添加了新账户，自动设置同步账户
+        if (mHasAddedAccount) {
+            Account[] accounts = getGoogleAccounts(); // 获取Google账户数组
+            if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
+                for (Account accountNew : accounts) {
+                    boolean found = false;
+                    for (Account accountOld : mOriAccounts) {
+                        if (TextUtils.equals(accountOld.name, accountNew.name)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        setSyncAccount(accountNew.name); // 设置同步账户
+                        break;
+                    }
+                }
+            }
+        }
+
+        refreshUI(); // 刷新用户界面
+    }
+
+    // onDestroy方法，Activity销毁时调用
+    @Override
+    protected void onDestroy() {
+        if (mReceiver != null) {
+            unregisterReceiver(mReceiver); // 注销BroadcastReceiver
+        }
+        super.onDestroy();
+    }
+
+    // loadAccountPreference方法，加载账户偏好设置
+    private void loadAccountPreference() {
+        mAccountCategory.removeAll(); // 移除所有账户偏好设置
+
+        Preference accountPref = new Preference(this); // 创建新的Preference
+        final String defaultAccount = getSyncAccountName(this); // 获取默认同步账户名
+        accountPref.setTitle(getString(R.string.preferences_account_title)); // 设置标题
+        accountPref.setSummary(getString(R.string.preferences_account_summary)); // 设置摘要
+        accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() { // 设置Preference点击事件监听器
+            public boolean onPreferenceClick(Preference preference) {
+                if (!GTaskSyncService.isSyncing()) { // 如果没有正在同步
+                    if (TextUtils.isEmpty(defaultAccount)) { // 如果默认账户名为空
+                        // 第一次设置账户
+                        showSelectAccountAlertDialog(); // 显示选择账户的AlertDialog
+                    } else {
+                        // 如果账户已经设置，提示用户风险
+                        showChangeAccountConfirmAlertDialog(); // 显示确认更改账户的AlertDialog
+                    }
+                } else {
+                    Toast.makeText(NotesPreferenceActivity.this,
+                                    R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+                            .show(); // 显示不能更改账户的Toast
+                }
+                return true; // 返回true表示已经处理了点击事件
+            }
+        });
+
+        mAccountCategory.addPreference(accountPref); // 将新的Preference添加到账户设置中
+    }
+
+    // loadSyncButton方法，加载同步按钮
+    private void loadSyncButton() {
+        Button syncButton = (Button) findViewById(R.id.preference_sync_button); // 获取同步按钮
+        TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview); // 获取最后同步时间的TextView
+
+        // 设置按钮状态
+        if (GTaskSyncService.isSyncing()) { // 如果正在同步
+            syncButton.setText(getString(R.string.preferences_button_sync_cancel)); // 设置按钮文本为"取消同步"
+            syncButton.setOnClickListener(new View.OnClickListener() { // 设置点击事件监听器
+                public void onClick(View v) {
+                    GTaskSyncService.cancelSync(NotesPreferenceActivity.this); // 取消同步
+                }
+            });
+        } else { // 如果没有正在同步
+            syncButton.setText(getString(R.string.preferences_button_sync_immediately)); // 设置按钮文本为"立即同步"
+            syncButton.setOnClickListener(new View.OnClickListener() { // 设置点击事件监听器
+                public void onClick(View v) {
+                    GTaskSyncService.startSync(NotesPreferenceActivity.this); // 开始同步
+                }
+            });
+        }
+        syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this))); // 设置按钮是否可用
+
+        // 设置最后同步时间
+        if (GTaskSyncService.isSyncing()) { // 如果正在同步
+            lastSyncTimeView.setText(GTaskSyncService.getProgressString()); // 设置同步进度字符串
+            lastSyncTimeView.setVisibility(View.VISIBLE); // 设置TextView可见
+        } else { // 如果没有正在同步
+            long lastSyncTime = getLastSyncTime(this); // 获取最后同步时间
+            if (lastSyncTime != 0) { // 如果最后同步时间不为0
+                lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
+                        DateFormat.format(getString(R.string.preferences_last_sync_time_format),
+                                lastSyncTime))); // 设置最后同步时间字符串
+                lastSyncTimeView.setVisibility(View.VISIBLE); // 设置TextView可见
+            } else {
+                lastSyncTimeView.setVisibility(View.GONE); // 设置TextView不可见
+            }
+        }
+    }
+
+    // refreshUI方法，用于刷新设置界面的用户界面
+    private void refreshUI() {
+        loadAccountPreference(); // 加载账户偏好设置
+        loadSyncButton(); // 加载同步按钮状态
+    }
+
+    // showSelectAccountAlertDialog方法，显示选择账户的AlertDialog
+    private void showSelectAccountAlertDialog() {
+        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this); // 创建AlertDialog.Builder对象
+
+        // inflate对话框标题布局
+        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+        titleTextView.setText(getString(R.string.preferences_dialog_select_account_title)); // 设置标题文本
+        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+        subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips)); // 设置副标题文本
+
+        dialogBuilder.setCustomTitle(titleView); // 设置自定义标题
+        dialogBuilder.setPositiveButton(null, null); // 设置PositiveButton，这里没有文本和监听器
+
+        Account[] accounts = getGoogleAccounts(); // 获取Google账户数组
+        String defAccount = getSyncAccountName(this); // 获取当前同步账户名
+
+        mOriAccounts = accounts; // 保存原始账户数组
+        mHasAddedAccount = false; // 初始化是否添加账户标志为false
+
+        if (accounts.length > 0) {
+            CharSequence[] items = new CharSequence[accounts.length]; // 创建账户名数组
+            final CharSequence[] itemMapping = items; // 用于映射点击的账户名
+            int checkedItem = -1; // 默认没有选中项
+            int index = 0;
+            for (Account account : accounts) {
+                if (TextUtils.equals(account.name, defAccount)) {
+                    checkedItem = index; // 如果账户名等于当前同步账户名，则设置为选中项
+                }
+                items[index++] = account.name; // 将账户名添加到数组
+            }
+            dialogBuilder.setSingleChoiceItems(items, checkedItem, // 设置单选项目
+                    new DialogInterface.OnClickListener() { // 设置点击事件监听器
+                        public void onClick(DialogInterface dialog, int which) {
+                            setSyncAccount(itemMapping[which].toString()); // 设置同步账户
+                            dialog.dismiss(); // 关闭对话框
+                            refreshUI(); // 刷新用户界面
+                        }
+                    });
+        }
+
+        // inflate添加账户的布局
+        View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
+        dialogBuilder.setView(addAccountView); // 设置对话框内容视图
+
+        final AlertDialog dialog = dialogBuilder.show(); // 显示对话框
+        addAccountView.setOnClickListener(new View.OnClickListener() { // 设置添加账户视图的点击事件监听器
+            public void onClick(View v) {
+                mHasAddedAccount = true; // 设置添加账户标志为true
+                Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS"); // 创建添加账户的Intent
+                intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] { // 设置Authorities过滤
+                        "gmail-ls"
+                });
+                startActivityForResult(intent, -1); // 启动结果Activity
+                dialog.dismiss(); // 关闭对话框
+            }
+        });
+    }
+
+    // showChangeAccountConfirmAlertDialog方法，显示更改账户的确认AlertDialog
+    private void showChangeAccountConfirmAlertDialog() {
+        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this); // 创建AlertDialog.Builder对象
+
+        // inflate对话框标题布局
+        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+        titleTextView.setText(getString(R.string.preferences_dialog_change_account_title, // 设置标题文本
+                getSyncAccountName(this)));
+        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+        subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg)); // 设置副标题文本
+        dialogBuilder.setCustomTitle(titleView); // 设置自定义标题
+
+        CharSequence[] menuItemArray = new CharSequence[] { // 创建菜单项数组
+                getString(R.string.preferences_menu_change_account),
+                getString(R.string.preferences_menu_remove_account),
+                getString(R.string.preferences_menu_cancel)
+        };
+        dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() { // 设置点击事件监听器
+            public void onClick(DialogInterface dialog, int which) {
+                if (which == 0) { // 如果点击更改账户
+                    showSelectAccountAlertDialog(); // 显示选择账户对话框
+                } else if (which == 1) { // 如果点击移除账户
+                    removeSyncAccount(); // 移除同步账户
+                    refreshUI(); // 刷新用户界面
+                }
+            }
+        });
+        dialogBuilder.show(); // 显示对话框
+    }
+
+    // getGoogleAccounts方法，获取Google账户数组
+    private Account[] getGoogleAccounts() {
+        AccountManager accountManager = AccountManager.get(this); // 获取AccountManager对象
+        return accountManager.getAccountsByType("com.google"); // 获取类型为"com.google"的账户数组
+    }
+
+    // setSyncAccount方法，设置同步账户
+    private void setSyncAccount(String account) {
+        if (!getSyncAccountName(this).equals(account)) { // 如果当前同步账户名不等于传入账户名
+            SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); // 获取SharedPreferences对象
+            SharedPreferences.Editor editor = settings.edit(); // 获取编辑器
+            if (account != null) {
+                editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account); // 设置同步账户名
+            } else {
+                editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); // 清除同步账户名
+            }
+            editor.commit(); // 提交更改
+
+            // 清除最后同步时间
+            setLastSyncTime(this, 0);
+
+            // 清除本地gtask相关信息
+            new Thread(new Runnable() { // 创建新线程
+                public void run() {
+                    ContentValues values = new ContentValues(); // 创建ContentValues对象
+                    values.put(NoteColumns.GTASK_ID, ""); // 清除GTASK_ID
+                    values.put(NoteColumns.SYNC_ID, 0); // 清除SYNC_ID
+                    getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null); // 更新笔记数据
+                }
+            }).start();
+
+            Toast.makeText(NotesPreferenceActivity.this, // 显示设置账户成功的Toast
+                    getString(R.string.preferences_toast_success_set_accout, account),
+                    Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    // removeSyncAccount方法，移除同步账户
+    private void removeSyncAccount() {
+        SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); // 获取SharedPreferences对象
+        SharedPreferences.Editor editor = settings.edit(); // 获取编辑器
+        if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) { // 如果包含同步账户名
+            editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME); // 移除同步账户名
+        }
+        if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) { // 如果包含最后同步时间
+            editor.remove(PREFERENCE_LAST_SYNC_TIME); // 移除最后同步时间
+        }
+        editor.commit(); // 提交更改
+
+        // 清除本地gtask相关信息
+        new Thread(new Runnable() { // 创建新线程
+            public void run() {
+                ContentValues values = new ContentValues(); // 创建ContentValues对象
+                values.put(NoteColumns.GTASK_ID, ""); // 清除GTASK_ID
+                values.put(NoteColumns.SYNC_ID, 0); // 清除SYNC_ID
+                getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null); // 更新笔记数据
+            }
+        }).start();
+    }
+
+    // getSyncAccountName方法，获取同步账户名
+    public static String getSyncAccountName(Context context) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); // 获取SharedPreferences对象
+        return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, ""); // 获取同步账户名，如果没有则返回空字符串
+    }
+
+    // setLastSyncTime方法，设置最后同步时间
+    public static void setLastSyncTime(Context context, long time) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); // 获取SharedPreferences对象
+        SharedPreferences.Editor editor = settings.edit(); // 获取编辑器
+        editor.putLong(PREFERENCE_LAST_SYNC_TIME, time); // 设置最后同步时间
+        editor.commit(); // 提交更改
+    }
+
+    // getLastSyncTime方法，获取最后同步时间
+    public static long getLastSyncTime(Context context) {
+        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); // 获取SharedPreferences对象
+        return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0); // 获取最后同步时间，如果没有则返回0
+    }
+
+    // GTaskReceiver类，继承自BroadcastReceiver，用于接收同步状态广播
+    private class GTaskReceiver extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            refreshUI(); // 刷新用户界面
+            if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) { // 如果正在同步
+                TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview); // 获取同步状态TextView
+                syncStatus.setText(intent.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG)); // 设置同步进度文本
+            }
+        }
+    }
+
+    // onOptionsItemSelected方法，处理选项菜单项的点击事件
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case android.R.id.home: // 如果点击的是home键
+                Intent intent = new Intent(this, NotesListActivity.class); // 创建Intent，跳转到NotesListActivity
+                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); // 添加标记，清除之前的Activity
+                startActivity(intent); // 启动新的Activity
+                return true; // 返回true表示已经处理了点击事件
+            default: // 默认情况
+                return false; // 返回false表示没有处理点击事件
+        }
+    }
+}