diff --git a/src/Notes-master/src/net/micode/notes/data/Contact.java b/src/Notes-master/src/net/micode/notes/data/Contact.java
index ab53547..ea388b2 100644
--- a/src/Notes-master/src/net/micode/notes/data/Contact.java
+++ b/src/Notes-master/src/net/micode/notes/data/Contact.java
@@ -25,11 +25,17 @@ import android.util.Log;
 
 import java.util.HashMap;
 
+/**
+ * 联系人工具类
+ * 用于根据电话号码获取联系人名称，并使用缓存提高性能
+ */
 public class Contact {
-    //建立联系人的哈希表
+    // 联系人缓存哈希表，用于存储电话号码和联系人名称的映射关系
     private static HashMap<String, String> sContactCache;
+    // 日志标签
     private static final String TAG = "Contact";
 
+    // 查询联系人的选择条件
     private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
     + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
     + " AND " + Data.RAW_CONTACT_ID + " IN "
@@ -37,30 +43,37 @@ public class Contact {
             + " FROM phone_lookup"
             + " WHERE min_match = '+')";
 
+    /**
+     * 根据电话号码获取联系人名称
+     * @param context 上下文对象
+     * @param phoneNumber 电话号码
+     * @return 联系人名称，如果未找到则返回null
+     */
     public static String getContact(Context context, String phoneNumber) {
-        //如果并没有哈希表则创建新的哈希表
+        // 如果缓存哈希表为空，则创建新的哈希表
         if(sContactCache == null) {
             sContactCache = new HashMap<String, String>();
         }
-        //在哈希表的缓存中找到了联系人的电话，返回相应的字符串
+        // 检查缓存中是否已有该电话号码对应的联系人
         if(sContactCache.containsKey(phoneNumber)) {
             return sContactCache.get(phoneNumber);
         }
-        //应该是直接在存储联系人和电话的菜单里面查找电话号码所对应的联系人
+        // 构建查询条件，替换min_match参数
         String selection = CALLER_ID_SELECTION.replace("+",
                 PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
 
+        // 查询联系人数据库
         Cursor cursor = context.getContentResolver().query(
                 Data.CONTENT_URI,
                 new String [] { Phone.DISPLAY_NAME },
                 selection,
                 new String[] { phoneNumber },
                 null);
-        //如果找到了联系人就返回名称，没有就返回无
+        // 如果找到联系人，返回名称并缓存
         if (cursor != null && cursor.moveToFirst()) {
-            //找到联系人后把联系人和电话号码存入缓存中，以便下一次查找
             try {
                 String name = cursor.getString(0);
+                // 将联系人和电话号码存入缓存中，以便下次查找
                 sContactCache.put(phoneNumber, name);
                 return name;
             } catch (IndexOutOfBoundsException e) {
diff --git a/src/Notes-master/src/net/micode/notes/data/Notes.java b/src/Notes-master/src/net/micode/notes/data/Notes.java
index 1717cd5..6dd8a97 100644
--- a/src/Notes-master/src/net/micode/notes/data/Notes.java
+++ b/src/Notes-master/src/net/micode/notes/data/Notes.java
@@ -17,264 +17,279 @@
 package net.micode.notes.data;
 
 import android.net.Uri;
-//纯定义，没有函数
+
+/**
+ * 笔记应用的数据结构定义类
+ * 包含所有笔记相关的常量、接口和内部类定义
+ * 纯定义类，不包含函数实现
+ */
 public class Notes {
-    public static final String AUTHORITY = "micode_notes";
-    public static final String TAG = "Notes";
-    public static final int TYPE_NOTE     = 0;
-    public static final int TYPE_FOLDER   = 1;
-    public static final int TYPE_SYSTEM   = 2;
+    public static final String AUTHORITY = "micode_notes";  // 内容提供者的权限标识
+    public static final String TAG = "Notes";              // 日志标签
+    public static final int TYPE_NOTE     = 0;              // 笔记类型：普通笔记
+    public static final int TYPE_FOLDER   = 1;              // 笔记类型：文件夹
+    public static final int TYPE_SYSTEM   = 2;              // 笔记类型：系统笔记
 
     /**
-     * Following IDs are system folders' identifiers
-     * {@link Notes#ID_ROOT_FOLDER } is default folder
-     * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
-     * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
+     * 以下是系统文件夹的标识符
+     * {@link Notes#ID_ROOT_FOLDER } 是默认文件夹
+     * {@link Notes#ID_TEMPARAY_FOLDER } 用于不属于任何文件夹的笔记
+     * {@link Notes#ID_CALL_RECORD_FOLDER} 用于存储通话记录
      */
-    public static final int ID_ROOT_FOLDER = 0;
-    public static final int ID_TEMPARAY_FOLDER = -1;
-    public static final int ID_CALL_RECORD_FOLDER = -2;
-    public static final int ID_TRASH_FOLER = -3;
-
-    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
-    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
-    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
-    public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
-    public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
-    public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
-
-    public static final int TYPE_WIDGET_INVALIDE      = -1;
-    public static final int TYPE_WIDGET_2X            = 0;
-    public static final int TYPE_WIDGET_4X            = 1;
+    public static final int ID_ROOT_FOLDER = 0;              // 默认根文件夹
+    public static final int ID_TEMPARAY_FOLDER = -1;         // 临时文件夹（用于无归属的笔记）
+    public static final int ID_CALL_RECORD_FOLDER = -2;      // 通话记录文件夹
+    public static final int ID_TRASH_FOLER = -3;             // 回收站文件夹
+
+    // Intent额外数据键定义
+    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";          // 提醒日期
+    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";  // 背景颜色ID
+    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";            // 小组件ID
+    public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";        // 小组件类型
+    public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";            // 文件夹ID
+    public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";            // 通话日期
+
+    // 小组件类型定义
+    public static final int TYPE_WIDGET_INVALIDE      = -1;  // 无效小组件
+    public static final int TYPE_WIDGET_2X            = 0;    // 2x大小的小组件
+    public static final int TYPE_WIDGET_4X            = 1;    // 4x大小的小组件
 
+    /**
+     * 数据类型常量定义
+     */
     public static class DataConstants {
-        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
-        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
+        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;        // 普通文本笔记类型
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;    // 通话记录笔记类型
     }
 
     /**
-     * Uri to query all notes and folders
+     * 查询所有笔记和文件夹的Uri
      */
     public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
 
     /**
-     * Uri to query data
+     * 查询笔记数据的Uri
      */
     public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
 
+    /**
+     * 笔记表的列名定义接口
+     */
     public interface NoteColumns {
         /**
-         * The unique ID for a row
-         * <P> Type: INTEGER (long) </P>
+         * 行的唯一ID
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String ID = "_id";
 
         /**
-         * The parent's id for note or folder
-         * <P> Type: INTEGER (long) </P>
+         * 笔记或文件夹的父级ID
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String PARENT_ID = "parent_id";
 
         /**
-         * Created data for note or folder
-         * <P> Type: INTEGER (long) </P>
+         * 笔记或文件夹的创建日期
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String CREATED_DATE = "created_date";
 
         /**
-         * Latest modified date
-         * <P> Type: INTEGER (long) </P>
+         * 最近修改日期
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String MODIFIED_DATE = "modified_date";
 
-
         /**
-         * Alert date
-         * <P> Type: INTEGER (long) </P>
+         * 提醒日期
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String ALERTED_DATE = "alert_date";
 
         /**
-         * Folder's name or text content of note
-         * <P> Type: TEXT </P>
+         * 文件夹名称或笔记内容摘要
+         * <P> 类型: TEXT </P>
          */
         public static final String SNIPPET = "snippet";
 
         /**
-         * Note's widget id
-         * <P> Type: INTEGER (long) </P>
+         * 笔记关联的小组件ID
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String WIDGET_ID = "widget_id";
 
         /**
-         * Note's widget type
-         * <P> Type: INTEGER (long) </P>
+         * 笔记关联的小组件类型
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String WIDGET_TYPE = "widget_type";
 
         /**
-         * Note's background color's id
-         * <P> Type: INTEGER (long) </P>
+         * 笔记背景颜色ID
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String BG_COLOR_ID = "bg_color_id";
 
         /**
-         * For text note, it doesn't has attachment, for multi-media
-         * note, it has at least one attachment
-         * <P> Type: INTEGER </P>
+         * 是否有附件标识
+         * <P> 类型: INTEGER </P>
+         * 对于文本笔记，没有附件；对于多媒体笔记，至少有一个附件
          */
         public static final String HAS_ATTACHMENT = "has_attachment";
 
         /**
-         * Folder's count of notes
-         * <P> Type: INTEGER (long) </P>
+         * 文件夹中包含的笔记数量
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String NOTES_COUNT = "notes_count";
 
         /**
-         * The file type: folder or note
-         * <P> Type: INTEGER </P>
+         * 文件类型：文件夹或笔记
+         * <P> 类型: INTEGER </P>
          */
         public static final String TYPE = "type";
 
         /**
-         * The last sync id
-         * <P> Type: INTEGER (long) </P>
+         * 最后同步ID
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String SYNC_ID = "sync_id";
 
         /**
-         * Sign to indicate local modified or not
-         * <P> Type: INTEGER </P>
+         * 本地修改状态标识
+         * <P> 类型: INTEGER </P>
          */
         public static final String LOCAL_MODIFIED = "local_modified";
 
         /**
-         * Original parent id before moving into temporary folder
-         * <P> Type : INTEGER </P>
+         * 移动到临时文件夹前的原始父级ID
+         * <P> 类型: INTEGER </P>
          */
         public static final String ORIGIN_PARENT_ID = "origin_parent_id";
 
         /**
-         * The gtask id
-         * <P> Type : TEXT </P>
+         * 谷歌任务ID
+         * <P> 类型: TEXT </P>
          */
         public static final String GTASK_ID = "gtask_id";
 
         /**
-         * The version code
-         * <P> Type : INTEGER (long) </P>
+         * 版本号
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String VERSION = "version";
     }
 
+    /**
+     * 笔记数据表的列名定义接口
+     */
     public interface DataColumns {
         /**
-         * The unique ID for a row
-         * <P> Type: INTEGER (long) </P>
+         * 行的唯一ID
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String ID = "_id";
 
         /**
-         * The MIME type of the item represented by this row.
-         * <P> Type: Text </P>
+         * 该行代表的项的MIME类型
+         * <P> 类型: Text </P>
          */
         public static final String MIME_TYPE = "mime_type";
 
         /**
-         * The reference id to note that this data belongs to
-         * <P> Type: INTEGER (long) </P>
+         * 该数据所属的笔记ID
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String NOTE_ID = "note_id";
 
         /**
-         * Created data for note or folder
-         * <P> Type: INTEGER (long) </P>
+         * 创建日期
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String CREATED_DATE = "created_date";
 
         /**
-         * Latest modified date
-         * <P> Type: INTEGER (long) </P>
+         * 最近修改日期
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String MODIFIED_DATE = "modified_date";
 
         /**
-         * Data's content
-         * <P> Type: TEXT </P>
+         * 数据内容
+         * <P> 类型: TEXT </P>
          */
         public static final String CONTENT = "content";
 
-
         /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * integer data type
-         * <P> Type: INTEGER </P>
+         * 通用数据列1，含义由{@link #MIMETYPE}决定，用于整数类型
+         * <P> 类型: INTEGER </P>
          */
         public static final String DATA1 = "data1";
 
         /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * integer data type
-         * <P> Type: INTEGER </P>
+         * 通用数据列2，含义由{@link #MIMETYPE}决定，用于整数类型
+         * <P> 类型: INTEGER </P>
          */
         public static final String DATA2 = "data2";
 
         /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
+         * 通用数据列3，含义由{@link #MIMETYPE}决定，用于文本类型
+         * <P> 类型: TEXT </P>
          */
         public static final String DATA3 = "data3";
 
         /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
+         * 通用数据列4，含义由{@link #MIMETYPE}决定，用于文本类型
+         * <P> 类型: TEXT </P>
          */
         public static final String DATA4 = "data4";
 
         /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
+         * 通用数据列5，含义由{@link #MIMETYPE}决定，用于文本类型
+         * <P> 类型: TEXT </P>
          */
         public static final String DATA5 = "data5";
     }
 
+    /**
+     * 文本笔记的数据类型定义
+     */
     public static final class TextNote implements DataColumns {
         /**
-         * Mode to indicate the text in check list mode or not
-         * <P> Type: Integer 1:check list mode 0: normal mode </P>
+         * 笔记模式：指示文本是否处于 checklist 模式
+         * <P> 类型: Integer 1:checklist模式 0:普通模式 </P>
          */
         public static final String MODE = DATA1;
 
-        public static final int MODE_CHECK_LIST = 1;
+        public static final int MODE_CHECK_LIST = 1;  // Checklist模式
 
-        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";  // 文本笔记集合的MIME类型
 
-        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";  // 单个文本笔记的MIME类型
 
-        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");  // 文本笔记的内容URI
     }
 
+    /**
+     * 通话记录笔记的数据类型定义
+     */
     public static final class CallNote implements DataColumns {
         /**
-         * Call date for this record
-         * <P> Type: INTEGER (long) </P>
+         * 通话记录的通话日期
+         * <P> 类型: INTEGER (long) </P>
          */
         public static final String CALL_DATE = DATA1;
 
         /**
-         * Phone number for this record
-         * <P> Type: TEXT </P>
+         * 通话记录的电话号码
+         * <P> 类型: TEXT </P>
          */
         public static final String PHONE_NUMBER = DATA3;
 
-        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
+        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";  // 通话记录集合的MIME类型
 
-        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
+        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";  // 单个通话记录的MIME类型
 
-        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
+        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");  // 通话记录的内容URI
     }
 }
diff --git a/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java b/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
index a1e64a2..9d11d9c 100644
--- a/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
+++ b/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
@@ -26,22 +26,26 @@ import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.DataConstants;
 import net.micode.notes.data.Notes.NoteColumns;
 
-//定义了一系列操作的函数
+/**
+ * 笔记数据库帮助类
+ * 负责数据库的创建、升级和维护
+ */
 public class NotesDatabaseHelper extends SQLiteOpenHelper {
-    private static final String DB_NAME = "note.db";
-
-    private static final int DB_VERSION = 4;
+    private static final String DB_NAME = "note.db";  // 数据库名称
+    private static final int DB_VERSION = 4;          // 数据库版本
 
+    /**
+     * 数据库表名定义接口
+     */
     public interface TABLE {
-        public static final String NOTE = "note";
-
-        public static final String DATA = "data";
+        public static final String NOTE = "note";  // 笔记表
+        public static final String DATA = "data";  // 笔记数据表
     }
 
-    private static final String TAG = "NotesDatabaseHelper";
-
-    private static NotesDatabaseHelper mInstance;
+    private static final String TAG = "NotesDatabaseHelper";  // 日志标签
+    private static NotesDatabaseHelper mInstance;              // 单例实例
 
+    // 创建笔记表的SQL语句
     private static final String CREATE_NOTE_TABLE_SQL =
         "CREATE TABLE " + TABLE.NOTE + "(" +
             NoteColumns.ID + " INTEGER PRIMARY KEY," +
@@ -61,8 +65,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
             NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
             NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
             NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
-        ")";
+        ");
 
+    // 创建笔记数据表的SQL语句
     private static final String CREATE_DATA_TABLE_SQL =
         "CREATE TABLE " + TABLE.DATA + "(" +
             DataColumns.ID + " INTEGER PRIMARY KEY," +
@@ -76,26 +81,20 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
             DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
             DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
             DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
-        ")";
+        ");
 
+    // 创建笔记数据表中note_id列的索引
     private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
         "CREATE INDEX IF NOT EXISTS note_id_index ON " +
-        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
+        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");"
 
     /**
-     * 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";
+    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";
 
     /**
-     * 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 " +
@@ -108,7 +107,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * 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 " +
@@ -120,7 +119,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * 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 " +
@@ -133,7 +132,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * Update note's content when insert data with type {@link DataConstants#NOTE}
+     * 当插入类型为{@link DataConstants#NOTE}的数据时更新笔记内容
      */
     private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
         "CREATE TRIGGER update_note_content_on_insert " +
@@ -146,7 +145,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * Update note's content when data with {@link DataConstants#NOTE} type has changed
+     * 当类型为{@link DataConstants#NOTE}的数据发生变化时更新笔记内容
      */
     private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
         "CREATE TRIGGER update_note_content_on_update " +
@@ -159,7 +158,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * Update note's content when data with {@link DataConstants#NOTE} type has deleted
+     * 当类型为{@link DataConstants#NOTE}的数据被删除时更新笔记内容
      */
     private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
         "CREATE TRIGGER update_note_content_on_delete " +
@@ -172,7 +171,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * 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 " +
@@ -183,7 +182,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * 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 " +
@@ -194,7 +193,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * 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 " +
@@ -206,18 +205,31 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
         " END";
 
+    /**
+     * 构造方法
+     * @param context 上下文对象
+     */
     public NotesDatabaseHelper(Context context) {
         super(context, DB_NAME, null, DB_VERSION);
     }
 
+    /**
+     * 创建笔记表
+     * @param db 数据库对象
+     */
     public void createNoteTable(SQLiteDatabase db) {
-        db.execSQL(CREATE_NOTE_TABLE_SQL);
-        reCreateNoteTableTriggers(db);
-        createSystemFolder(db);
+        db.execSQL(CREATE_NOTE_TABLE_SQL);  // 创建笔记表结构
+        reCreateNoteTableTriggers(db);      // 重建笔记表触发器
+        createSystemFolder(db);             // 创建系统文件夹
         Log.d(TAG, "note table has been created");
     }
 
+    /**
+     * 重建笔记表的触发器
+     * @param db 数据库对象
+     */
     private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+        // 删除现有触发器
         db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
         db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
         db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
@@ -226,6 +238,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
         db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
 
+        // 创建新触发器
         db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
         db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
         db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
@@ -235,18 +248,22 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
     }
 
+    /**
+     * 创建系统文件夹
+     * @param db 数据库对象
+     */
     private void createSystemFolder(SQLiteDatabase db) {
         ContentValues values = new ContentValues();
 
         /**
-         * call record foler for call notes
+         * 通话记录文件夹，用于存储通话记录笔记
          */
         values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
         db.insert(TABLE.NOTE, null, values);
 
         /**
-         * root folder which is default folder
+         * 根文件夹，默认文件夹
          */
         values.clear();
         values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
@@ -254,7 +271,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.insert(TABLE.NOTE, null, values);
 
         /**
-         * temporary folder which is used for moving note
+         * 临时文件夹，用于移动笔记时临时存储
          */
         values.clear();
         values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
@@ -262,7 +279,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.insert(TABLE.NOTE, null, values);
 
         /**
-         * create trash folder
+         * 回收站文件夹
          */
         values.clear();
         values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
@@ -270,23 +287,38 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.insert(TABLE.NOTE, null, values);
     }
 
+    /**
+     * 创建笔记数据表
+     * @param db 数据库对象
+     */
     public void createDataTable(SQLiteDatabase db) {
-        db.execSQL(CREATE_DATA_TABLE_SQL);
-        reCreateDataTableTriggers(db);
-        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
+        db.execSQL(CREATE_DATA_TABLE_SQL);           // 创建笔记数据表结构
+        reCreateDataTableTriggers(db);               // 重建笔记数据表触发器
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);    // 创建note_id列索引
         Log.d(TAG, "data table has been created");
     }
 
+    /**
+     * 重建笔记数据表的触发器
+     * @param db 数据库对象
+     */
     private void reCreateDataTableTriggers(SQLiteDatabase db) {
+        // 删除现有触发器
         db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
         db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
         db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
 
+        // 创建新触发器
         db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
         db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
         db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
     }
 
+    /**
+     * 获取NotesDatabaseHelper的单例实例
+     * @param context 上下文对象
+     * @return NotesDatabaseHelper的单例实例
+     */
     static synchronized NotesDatabaseHelper getInstance(Context context) {
         if (mInstance == null) {
             mInstance = new NotesDatabaseHelper(context);
@@ -294,67 +326,98 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         return mInstance;
     }
 
+    /**
+     * 当数据库首次创建时调用
+     * @param db 数据库对象
+     */
     @Override
     public void onCreate(SQLiteDatabase db) {
-        createNoteTable(db);
-        createDataTable(db);
+        createNoteTable(db);   // 创建笔记表
+        createDataTable(db);   // 创建笔记数据表
     }
 
+    /**
+     * 当数据库版本需要更新时调用
+     * @param db 数据库对象
+     * @param oldVersion 旧版本号
+     * @param newVersion 新版本号
+     */
     @Override
     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-        boolean reCreateTriggers = false;
-        boolean skipV2 = false;
+        boolean reCreateTriggers = false;  // 是否需要重建触发器
+        boolean skipV2 = false;            // 是否跳过版本2的升级
 
+        // 从版本1升级
         if (oldVersion == 1) {
             upgradeToV2(db);
-            skipV2 = true; // this upgrade including the upgrade from v2 to v3
+            skipV2 = true; // 版本2到版本3的升级已经包含在版本1到版本2的升级中
             oldVersion++;
         }
 
+        // 从版本2升级（跳过已在版本1升级中处理的情况）
         if (oldVersion == 2 && !skipV2) {
             upgradeToV3(db);
             reCreateTriggers = true;
             oldVersion++;
         }
 
+        // 从版本3升级
         if (oldVersion == 3) {
             upgradeToV4(db);
             oldVersion++;
         }
 
+        // 如果需要，重建触发器
         if (reCreateTriggers) {
             reCreateNoteTableTriggers(db);
             reCreateDataTableTriggers(db);
         }
 
+        // 检查升级是否成功
         if (oldVersion != newVersion) {
             throw new IllegalStateException("Upgrade notes database to version " + newVersion
-                    + "fails");
+                    + " fails");
         }
     }
 
+    /**
+     * 将数据库升级到版本2
+     * @param db 数据库对象
+     */
     private void upgradeToV2(SQLiteDatabase db) {
+        // 删除旧表
         db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
         db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+        // 创建新表
         createNoteTable(db);
         createDataTable(db);
     }
 
+    /**
+     * 将数据库升级到版本3
+     * @param db 数据库对象
+     */
     private void upgradeToV3(SQLiteDatabase db) {
-        // 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
+        
+        // 添加gtask_id列用于同步
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
                 + " TEXT NOT NULL DEFAULT ''");
-        // add a trash system folder
+        
+        // 添加回收站系统文件夹
         ContentValues values = new ContentValues();
         values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
         db.insert(TABLE.NOTE, null, values);
     }
 
+    /**
+     * 将数据库升级到版本4
+     * @param db 数据库对象
+     */
     private void upgradeToV4(SQLiteDatabase db) {
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
                 + " INTEGER NOT NULL DEFAULT 0");
diff --git a/src/Notes-master/src/net/micode/notes/data/NotesProvider.java b/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
index edb0a60..fe3ccf3 100644
--- a/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
+++ b/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
@@ -35,35 +35,50 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 
 
+/**
+ * 笔记内容提供者类
+ * 负责处理笔记和数据的CRUD操作，提供ContentProvider接口
+ * 支持搜索和搜索建议功能
+ */
 public class NotesProvider extends ContentProvider {
-    private static final UriMatcher mMatcher;
+    private static final UriMatcher mMatcher;  // URI匹配器，用于解析不同类型的URI请求
 
-    private NotesDatabaseHelper mHelper;
+    private NotesDatabaseHelper mHelper;        // 数据库帮助类实例
 
-    private static final String TAG = "NotesProvider";
+    private static final String TAG = "NotesProvider";  // 日志标签
 
-    private static final int URI_NOTE            = 1;
-    private static final int URI_NOTE_ITEM       = 2;
-    private static final int URI_DATA            = 3;
-    private static final int URI_DATA_ITEM       = 4;
+    // URI类型常量定义
+    private static final int URI_NOTE            = 1;  // 笔记集合URI
+    private static final int URI_NOTE_ITEM       = 2;  // 单个笔记URI
+    private static final int URI_DATA            = 3;  // 笔记数据集合URI
+    private static final int URI_DATA_ITEM       = 4;  // 单个笔记数据URI
 
-    private static final int URI_SEARCH          = 5;
-    private static final int URI_SEARCH_SUGGEST  = 6;
+    private static final int URI_SEARCH          = 5;  // 搜索URI
+    private static final int URI_SEARCH_SUGGEST  = 6;  // 搜索建议URI
 
+    /**
+     * 静态初始化块 - 配置URI匹配规则
+     */
     static {
         mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        // 笔记集合URI
         mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
+        // 单个笔记URI（带ID）
         mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
+        // 笔记数据集合URI
         mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
+        // 单个笔记数据URI（带ID）
         mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
+        // 搜索URI
         mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
+        // 搜索建议URI（两种形式）
         mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
         mMatcher.addURI(Notes.AUTHORITY, 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.
+     * 搜索结果的投影定义
+     * x'0A' 表示SQLite中的换行符\n，搜索结果中会去除换行符和空白以显示更多信息
      */
     private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
         + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
@@ -73,18 +88,35 @@ public class NotesProvider extends ContentProvider {
         + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
         + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
 
+    /**
+     * 笔记片段搜索查询语句
+     * 只搜索非回收站中的普通笔记，根据内容片段进行模糊匹配
+     */
     private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
         + " FROM " + TABLE.NOTE
         + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
         + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
         + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
 
+    /**
+     * 内容提供者创建时调用
+     * 初始化数据库帮助类实例
+     */
     @Override
     public boolean onCreate() {
         mHelper = NotesDatabaseHelper.getInstance(getContext());
         return true;
     }
 
+    /**
+     * 查询方法 - 处理对笔记和数据的查询请求
+     * @param uri 请求的URI
+     * @param projection 查询的列
+     * @param selection 查询条件
+     * @param selectionArgs 查询条件参数
+     * @param sortOrder 排序方式
+     * @return 查询结果游标
+     */
     @Override
     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
             String sortOrder) {
@@ -92,26 +124,26 @@ public class NotesProvider extends ContentProvider {
         SQLiteDatabase db = mHelper.getReadableDatabase();
         String id = null;
         switch (mMatcher.match(uri)) {
-            case URI_NOTE:
+            case URI_NOTE:  // 查询笔记集合
                 c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
-            case URI_NOTE_ITEM:
+            case URI_NOTE_ITEM:  // 查询单个笔记
                 id = uri.getPathSegments().get(1);
                 c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
-            case URI_DATA:
+            case URI_DATA:  // 查询笔记数据集合
                 c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
-            case URI_DATA_ITEM:
+            case URI_DATA_ITEM:  // 查询单个笔记数据
                 id = uri.getPathSegments().get(1);
                 c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
-            case URI_SEARCH:
-            case URI_SEARCH_SUGGEST:
+            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");
@@ -147,15 +179,21 @@ public class NotesProvider extends ContentProvider {
         return c;
     }
 
+    /**
+     * 插入方法 - 处理对笔记和数据的插入请求
+     * @param uri 请求的URI
+     * @param values 要插入的数据
+     * @return 插入后的资源URI
+     */
     @Override
     public Uri insert(Uri uri, ContentValues values) {
         SQLiteDatabase db = mHelper.getWritableDatabase();
         long dataId = 0, noteId = 0, insertedId = 0;
         switch (mMatcher.match(uri)) {
-            case URI_NOTE:
+            case URI_NOTE:  // 插入笔记
                 insertedId = noteId = db.insert(TABLE.NOTE, null, values);
                 break;
-            case URI_DATA:
+            case URI_DATA:  // 插入笔记数据
                 if (values.containsKey(DataColumns.NOTE_ID)) {
                     noteId = values.getAsLong(DataColumns.NOTE_ID);
                 } else {
@@ -166,13 +204,13 @@ public class NotesProvider extends ContentProvider {
             default:
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
-        // Notify the note uri
+        // 通知笔记URI数据变化
         if (noteId > 0) {
             getContext().getContentResolver().notifyChange(
                     ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
         }
 
-        // Notify the data uri
+        // 通知数据URI数据变化
         if (dataId > 0) {
             getContext().getContentResolver().notifyChange(
                     ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
@@ -181,6 +219,13 @@ public class NotesProvider extends ContentProvider {
         return ContentUris.withAppendedId(uri, insertedId);
     }
 
+    /**
+     * 删除方法 - 处理对笔记和数据的删除请求
+     * @param uri 请求的URI
+     * @param selection 删除条件
+     * @param selectionArgs 删除条件参数
+     * @return 删除的行数
+     */
     @Override
     public int delete(Uri uri, String selection, String[] selectionArgs) {
         int count = 0;
@@ -227,28 +272,37 @@ public class NotesProvider extends ContentProvider {
         return count;
     }
 
+    /**
+     * 更新数据库中的数据
+     * @param uri 要更新的内容URI
+     * @param values 要更新的列值
+     * @param selection 更新条件
+     * @param selectionArgs 更新条件参数
+     * @return 更新的行数
+     */
     @Override
     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
         int count = 0;
         String id = null;
         SQLiteDatabase db = mHelper.getWritableDatabase();
-        boolean updateData = false;
+        boolean updateData = false;  // 是否更新了数据内容
+        
         switch (mMatcher.match(uri)) {
-            case URI_NOTE:
-                increaseNoteVersion(-1, selection, selectionArgs);
+            case URI_NOTE:  // 更新所有笔记
+                increaseNoteVersion(-1, selection, selectionArgs);  // 增加笔记版本号
                 count = db.update(TABLE.NOTE, values, selection, selectionArgs);
                 break;
-            case URI_NOTE_ITEM:
+            case URI_NOTE_ITEM:  // 更新单个笔记
                 id = uri.getPathSegments().get(1);
-                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
+                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);  // 增加笔记版本号
                 count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs);
                 break;
-            case URI_DATA:
+            case URI_DATA:  // 更新所有笔记数据
                 count = db.update(TABLE.DATA, values, selection, selectionArgs);
                 updateData = true;
                 break;
-            case URI_DATA_ITEM:
+            case URI_DATA_ITEM:  // 更新单个笔记数据
                 id = uri.getPathSegments().get(1);
                 count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs);
@@ -260,17 +314,31 @@ public class NotesProvider extends ContentProvider {
 
         if (count > 0) {
             if (updateData) {
+                // 如果更新了数据内容，也通知笔记URI的观察者
                 getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
             }
+            // 通知URI的观察者数据已更改
             getContext().getContentResolver().notifyChange(uri, null);
         }
         return count;
     }
 
+    /**
+     * 解析并格式化查询条件
+     * @param selection 原始查询条件
+     * @return 格式化后的查询条件
+     */
     private String parseSelection(String selection) {
-        return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
+        return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ")" : "");
     }
 
+    /**
+     * 增加笔记的版本号
+     * 用于记录笔记的修改版本，支持并发更新场景
+     * @param id 笔记ID，-1表示更新所有符合条件的笔记
+     * @param selection 查询条件
+     * @param selectionArgs 查询条件参数
+     */
     private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
         StringBuilder sql = new StringBuilder(120);
         sql.append("UPDATE ");
@@ -296,6 +364,11 @@ public class NotesProvider extends ContentProvider {
         mHelper.getWritableDatabase().execSQL(sql.toString());
     }
 
+    /**
+     * 获取内容URI对应的MIME类型
+     * @param uri 内容URI
+     * @return MIME类型 - 目前未完全实现，返回null
+     */
     @Override
     public String getType(Uri uri) {
         // TODO Auto-generated method stub
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java b/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
index 3a2050b..47e11e3 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
@@ -25,11 +25,22 @@ import org.json.JSONException;
 import org.json.JSONObject;
 
 
+/**
+ * 元数据类 - 继承自Task类
+ * 用于处理Google任务的元数据信息
+ */
 public class MetaData extends Task {
+    // 日志标签
     private final static String TAG = MetaData.class.getSimpleName();
 
+    // 相关的Google任务ID
     private String mRelatedGid = null;
 
+    /**
+     * 设置元数据
+     * @param gid Google任务ID
+     * @param metaInfo 元信息JSON对象
+     */
     public void setMeta(String gid, JSONObject metaInfo) {
         try {
             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
@@ -40,15 +51,27 @@ public class MetaData extends Task {
         setName(GTaskStringUtils.META_NOTE_NAME);
     }
 
+    /**
+     * 获取相关的Google任务ID
+     * @return 相关的Google任务ID
+     */
     public String getRelatedGid() {
         return mRelatedGid;
     }
 
+    /**
+     * 判断是否值得保存
+     * @return 如果有元信息则返回true，否则返回false
+     */
     @Override
     public boolean isWorthSaving() {
         return getNotes() != null;
     }
 
+    /**
+     * 通过远程JSON设置内容
+     * @param js 远程JSON对象
+     */
     @Override
     public void setContentByRemoteJSON(JSONObject js) {
         super.setContentByRemoteJSON(js);
@@ -63,17 +86,33 @@ public class MetaData extends Task {
         }
     }
 
+    /**
+     * 通过本地JSON设置内容
+     * 该方法不应该被调用
+     * @param js 本地JSON对象
+     */
     @Override
     public void setContentByLocalJSON(JSONObject js) {
         // this function should not be called
         throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
     }
 
+    /**
+     * 从内容获取本地JSON
+     * 该方法不应该被调用
+     * @return 本地JSON对象
+     */
     @Override
     public JSONObject getLocalJSONFromContent() {
         throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
     }
 
+    /**
+     * 获取同步操作
+     * 该方法不应该被调用
+     * @param c 游标
+     * @return 同步操作类型
+     */
     @Override
     public int getSyncAction(Cursor c) {
         throw new IllegalAccessError("MetaData:getSyncAction should not be called");
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/Node.java b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
index 63950e0..eb88d61 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
@@ -20,33 +20,32 @@ import android.database.Cursor;
 
 import org.json.JSONObject;
 
+/**
+ * 同步节点抽象类 - 定义了同步操作的基本结构和接口
+ * 所有需要进行同步的对象都应该继承这个类
+ */
 public abstract class Node {
-    public static final int SYNC_ACTION_NONE = 0;
-
-    public static final int SYNC_ACTION_ADD_REMOTE = 1;
-
-    public static final int SYNC_ACTION_ADD_LOCAL = 2;
-
-    public static final int SYNC_ACTION_DEL_REMOTE = 3;
-
-    public static final int SYNC_ACTION_DEL_LOCAL = 4;
-
-    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
-
-    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
-
-    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
-
-    public static final int SYNC_ACTION_ERROR = 8;
-
-    private String mGid;
-
-    private String mName;
-
-    private long mLastModified;
-
-    private boolean mDeleted;
-
+    // 同步操作类型常量
+    public static final int SYNC_ACTION_NONE = 0;              // 无操作
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;        // 远程添加
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;         // 本地添加
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;        // 远程删除
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;         // 本地删除
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;     // 远程更新
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;      // 本地更新
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;   // 更新冲突
+    public static final int SYNC_ACTION_ERROR = 8;             // 同步错误
+
+    // 成员变量
+    private String mGid;           // Google任务ID
+    private String mName;          // 节点名称
+    private long mLastModified;    // 最后修改时间戳
+    private boolean mDeleted;      // 是否已删除
+
+    /**
+     * 构造函数
+     * 初始化节点的基本属性
+     */
     public Node() {
         mGid = null;
         mName = "";
@@ -54,46 +53,105 @@ public abstract class Node {
         mDeleted = false;
     }
 
+    /**
+     * 获取创建操作的JSON对象
+     * @param actionId 操作ID
+     * @return 创建操作的JSON对象
+     */
     public abstract JSONObject getCreateAction(int actionId);
 
+    /**
+     * 获取更新操作的JSON对象
+     * @param actionId 操作ID
+     * @return 更新操作的JSON对象
+     */
     public abstract JSONObject getUpdateAction(int actionId);
 
+    /**
+     * 通过远程JSON设置内容
+     * @param js 远程JSON对象
+     */
     public abstract void setContentByRemoteJSON(JSONObject js);
 
+    /**
+     * 通过本地JSON设置内容
+     * @param js 本地JSON对象
+     */
     public abstract void setContentByLocalJSON(JSONObject js);
 
+    /**
+     * 从内容获取本地JSON
+     * @return 本地JSON对象
+     */
     public abstract JSONObject getLocalJSONFromContent();
 
+    /**
+     * 获取同步操作类型
+     * @param c 游标
+     * @return 同步操作类型
+     */
     public abstract int getSyncAction(Cursor c);
 
+    /**
+     * 设置Google任务ID
+     * @param gid Google任务ID
+     */
     public void setGid(String gid) {
         this.mGid = gid;
     }
 
+    /**
+     * 设置节点名称
+     * @param name 节点名称
+     */
     public void setName(String name) {
         this.mName = name;
     }
 
+    /**
+     * 设置最后修改时间
+     * @param lastModified 最后修改时间戳
+     */
     public void setLastModified(long lastModified) {
         this.mLastModified = lastModified;
     }
 
+    /**
+     * 设置删除状态
+     * @param deleted 是否已删除
+     */
     public void setDeleted(boolean deleted) {
         this.mDeleted = deleted;
     }
 
+    /**
+     * 获取Google任务ID
+     * @return Google任务ID
+     */
     public String getGid() {
         return this.mGid;
     }
 
+    /**
+     * 获取节点名称
+     * @return 节点名称
+     */
     public String getName() {
         return this.mName;
     }
 
+    /**
+     * 获取最后修改时间
+     * @return 最后修改时间戳
+     */
     public long getLastModified() {
         return this.mLastModified;
     }
 
+    /**
+     * 获取删除状态
+     * @return 是否已删除
+     */
     public boolean getDeleted() {
         return this.mDeleted;
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java b/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
index d3ec3be..a11dcc8 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
@@ -35,42 +35,44 @@ import org.json.JSONException;
 import org.json.JSONObject;
 
 
+/**
+ * SQL数据处理类 - 负责处理笔记数据的CRUD操作
+ * 与ContentResolver交互，实现数据的加载、保存和更新
+ */
 public class SqlData {
+    // 日志标签
     private static final String TAG = SqlData.class.getSimpleName();
 
+    // 无效ID常量
     private static final int INVALID_ID = -99999;
 
+    // 数据查询投影
     public static final String[] PROJECTION_DATA = new String[] {
             DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
             DataColumns.DATA3
     };
 
-    public static final int DATA_ID_COLUMN = 0;
-
-    public static final int DATA_MIME_TYPE_COLUMN = 1;
-
-    public static final int DATA_CONTENT_COLUMN = 2;
-
-    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
-
-    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
-
-    private ContentResolver mContentResolver;
-
-    private boolean mIsCreate;
-
-    private long mDataId;
-
-    private String mDataMimeType;
-
-    private String mDataContent;
-
-    private long mDataContentData1;
-
-    private String mDataContentData3;
-
-    private ContentValues mDiffDataValues;
-
+    // 投影列索引常量
+    public static final int DATA_ID_COLUMN = 0;                    // 数据ID列
+    public static final int DATA_MIME_TYPE_COLUMN = 1;             // MIME类型列
+    public static final int DATA_CONTENT_COLUMN = 2;               // 内容列
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;        // DATA1列
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;        // DATA3列
+
+    // 成员变量
+    private ContentResolver mContentResolver;  // 内容解析器
+    private boolean mIsCreate;                 // 是否为创建模式
+    private long mDataId;                      // 数据ID
+    private String mDataMimeType;              // 数据MIME类型
+    private String mDataContent;               // 数据内容
+    private long mDataContentData1;            // DATA1字段值
+    private String mDataContentData3;          // DATA3字段值
+    private ContentValues mDiffDataValues;     // 差异数据值，用于更新操作
+
+    /**
+     * 构造函数 - 创建新的数据对象
+     * @param context 上下文对象
+     */
     public SqlData(Context context) {
         mContentResolver = context.getContentResolver();
         mIsCreate = true;
@@ -82,6 +84,11 @@ public class SqlData {
         mDiffDataValues = new ContentValues();
     }
 
+    /**
+     * 构造函数 - 从数据库游标创建数据对象
+     * @param context 上下文对象
+     * @param c 数据库游标
+     */
     public SqlData(Context context, Cursor c) {
         mContentResolver = context.getContentResolver();
         mIsCreate = false;
@@ -89,6 +96,10 @@ public class SqlData {
         mDiffDataValues = new ContentValues();
     }
 
+    /**
+     * 从游标加载数据
+     * @param c 数据库游标
+     */
     private void loadFromCursor(Cursor c) {
         mDataId = c.getLong(DATA_ID_COLUMN);
         mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@@ -97,6 +108,11 @@ public class SqlData {
         mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
     }
 
+    /**
+     * 通过JSON对象设置数据内容
+     * @param js JSON对象，包含数据内容
+     * @throws JSONException JSON解析异常
+     */
     public void setContent(JSONObject js) throws JSONException {
         long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
         if (mIsCreate || mDataId != dataId) {
@@ -130,6 +146,11 @@ public class SqlData {
         mDataContentData3 = dataContentData3;
     }
 
+    /**
+     * 获取数据内容的JSON对象
+     * @return 包含数据内容的JSON对象
+     * @throws JSONException JSON解析异常
+     */
     public JSONObject getContent() throws JSONException {
         if (mIsCreate) {
             Log.e(TAG, "it seems that we haven't created this in database yet");
@@ -144,6 +165,13 @@ public class SqlData {
         return js;
     }
 
+    /**
+     * 提交数据到数据库
+     * @param noteId 笔记ID
+     * @param validateVersion 是否验证版本
+     * @param version 版本号
+     * @throws ActionFailureException 操作失败异常
+     */
     public void commit(long noteId, boolean validateVersion, long version) {
 
         if (mIsCreate) {
@@ -183,6 +211,10 @@ public class SqlData {
         mIsCreate = false;
     }
 
+    /**
+     * 获取数据ID
+     * @return 数据ID
+     */
     public long getId() {
         return mDataId;
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
index 79a4095..bf7cbc3 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
@@ -38,11 +38,21 @@ import org.json.JSONObject;
 import java.util.ArrayList;
 
 
+/**
+ * SqlNote 类 - 用于管理笔记和相关数据的同步操作
+ * 该类负责将笔记数据与 Google Tasks 进行同步，处理数据的创建、更新和删除操作
+ */
 public class SqlNote {
     private static final String TAG = SqlNote.class.getSimpleName();
 
+    /**
+     * 无效ID常量 - 用于标记未创建或无效的笔记ID
+     */
     private static final int INVALID_ID = -99999;
 
+    /**
+     * 笔记查询投影数组 - 定义从数据库查询笔记时返回的列
+     */
     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,
@@ -52,76 +62,185 @@ public class SqlNote {
             NoteColumns.VERSION
     };
 
+    /**
+     * 笔记ID列索引 - PROJECTION_NOTE数组中ID列的位置
+     */
     public static final int ID_COLUMN = 0;
 
+    /**
+     * 提醒日期列索引 - PROJECTION_NOTE数组中提醒日期列的位置
+     */
     public static final int ALERTED_DATE_COLUMN = 1;
 
+    /**
+     * 背景颜色ID列索引 - PROJECTION_NOTE数组中背景颜色ID列的位置
+     */
     public static final int BG_COLOR_ID_COLUMN = 2;
 
+    /**
+     * 创建日期列索引 - PROJECTION_NOTE数组中创建日期列的位置
+     */
     public static final int CREATED_DATE_COLUMN = 3;
 
+    /**
+     * 是否有附件列索引 - PROJECTION_NOTE数组中是否有附件列的位置
+     */
     public static final int HAS_ATTACHMENT_COLUMN = 4;
 
+    /**
+     * 修改日期列索引 - PROJECTION_NOTE数组中修改日期列的位置
+     */
     public static final int MODIFIED_DATE_COLUMN = 5;
 
+    /**
+     * 笔记数量列索引 - PROJECTION_NOTE数组中笔记数量列的位置
+     */
     public static final int NOTES_COUNT_COLUMN = 6;
 
+    /**
+     * 父文件夹ID列索引 - PROJECTION_NOTE数组中父文件夹ID列的位置
+     */
     public static final int PARENT_ID_COLUMN = 7;
 
+    /**
+     * 笔记摘要列索引 - PROJECTION_NOTE数组中笔记摘要列的位置
+     */
     public static final int SNIPPET_COLUMN = 8;
 
+    /**
+     * 笔记类型列索引 - PROJECTION_NOTE数组中笔记类型列的位置
+     */
     public static final int TYPE_COLUMN = 9;
 
+    /**
+     * 小部件ID列索引 - PROJECTION_NOTE数组中小部件ID列的位置
+     */
     public static final int WIDGET_ID_COLUMN = 10;
 
+    /**
+     * 小部件类型列索引 - PROJECTION_NOTE数组中小部件类型列的位置
+     */
     public static final int WIDGET_TYPE_COLUMN = 11;
 
+    /**
+     * 同步ID列索引 - PROJECTION_NOTE数组中同步ID列的位置
+     */
     public static final int SYNC_ID_COLUMN = 12;
 
+    /**
+     * 本地修改状态列索引 - PROJECTION_NOTE数组中本地修改状态列的位置
+     */
     public static final int LOCAL_MODIFIED_COLUMN = 13;
 
+    /**
+     * 原始父文件夹ID列索引 - PROJECTION_NOTE数组中原始父文件夹ID列的位置
+     */
     public static final int ORIGIN_PARENT_ID_COLUMN = 14;
 
+    /**
+     * Google Tasks ID列索引 - PROJECTION_NOTE数组中Google Tasks ID列的位置
+     */
     public static final int GTASK_ID_COLUMN = 15;
 
+    /**
+     * 版本号列索引 - PROJECTION_NOTE数组中版本号列的位置
+     */
     public static final int VERSION_COLUMN = 16;
 
+    /**
+     * 上下文对象 - 用于访问应用资源和内容解析器
+     */
     private Context mContext;
 
+    /**
+     * 内容解析器 - 用于访问ContentProvider进行数据操作
+     */
     private ContentResolver mContentResolver;
 
+    /**
+     * 创建标志 - 标记笔记是否为新创建（未保存到数据库）
+     */
     private boolean mIsCreate;
 
+    /**
+     * 笔记ID - 唯一标识一个笔记
+     */
     private long mId;
 
+    /**
+     * 提醒日期 - 笔记的提醒时间戳
+     */
     private long mAlertDate;
 
+    /**
+     * 背景颜色ID - 笔记的背景颜色资源ID
+     */
     private int mBgColorId;
 
+    /**
+     * 创建日期 - 笔记创建的时间戳
+     */
     private long mCreatedDate;
 
+    /**
+     * 是否有附件 - 标记笔记是否包含附件（0表示无，1表示有）
+     */
     private int mHasAttachment;
 
+    /**
+     * 修改日期 - 笔记最后修改的时间戳
+     */
     private long mModifiedDate;
 
+    /**
+     * 父文件夹ID - 笔记所属文件夹的ID
+     */
     private long mParentId;
 
+    /**
+     * 笔记摘要 - 笔记内容的简短描述
+     */
     private String mSnippet;
 
+    /**
+     * 笔记类型 - 区分笔记、文件夹、系统文件夹等类型
+     */
     private int mType;
 
+    /**
+     * 小部件ID - 关联的应用小部件ID
+     */
     private int mWidgetId;
 
+    /**
+     * 小部件类型 - 关联的应用小部件类型
+     */
     private int mWidgetType;
 
+    /**
+     * 原始父文件夹ID - 笔记原始所属文件夹的ID（用于移动操作）
+     */
     private long mOriginParent;
 
+    /**
+     * 版本号 - 用于处理并发编辑和同步冲突
+     */
     private long mVersion;
 
+    /**
+     * 差异内容值 - 存储笔记属性的变更，用于数据库更新
+     */
     private ContentValues mDiffNoteValues;
 
+    /**
+     * 数据列表 - 存储与笔记关联的详细内容数据
+     */
     private ArrayList<SqlData> mDataList;
 
+    /**
+     * 构造函数 - 创建一个新的笔记对象
+     * @param context 上下文对象
+     */
     public SqlNote(Context context) {
         mContext = context;
         mContentResolver = context.getContentResolver();
@@ -143,6 +262,11 @@ public class SqlNote {
         mDataList = new ArrayList<SqlData>();
     }
 
+    /**
+     * 构造函数 - 从数据库游标创建笔记对象
+     * @param context 上下文对象
+     * @param c 包含笔记数据的数据库游标
+     */
     public SqlNote(Context context, Cursor c) {
         mContext = context;
         mContentResolver = context.getContentResolver();
@@ -154,6 +278,11 @@ public class SqlNote {
         mDiffNoteValues = new ContentValues();
     }
 
+    /**
+     * 构造函数 - 根据笔记ID创建笔记对象
+     * @param context 上下文对象
+     * @param id 笔记ID
+     */
     public SqlNote(Context context, long id) {
         mContext = context;
         mContentResolver = context.getContentResolver();
@@ -163,9 +292,12 @@ public class SqlNote {
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
         mDiffNoteValues = new ContentValues();
-
     }
 
+    /**
+     * 根据ID从数据库加载笔记数据
+     * @param id 笔记ID
+     */
     private void loadFromCursor(long id) {
         Cursor c = null;
         try {
@@ -185,6 +317,10 @@ public class SqlNote {
         }
     }
 
+    /**
+     * 从数据库游标加载笔记数据
+     * @param c 包含笔记数据的游标
+     */
     private void loadFromCursor(Cursor c) {
         mId = c.getLong(ID_COLUMN);
         mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@@ -200,6 +336,10 @@ public class SqlNote {
         mVersion = c.getLong(VERSION_COLUMN);
     }
 
+    /**
+     * 加载笔记关联的数据内容
+     * 从数据库查询与当前笔记关联的所有数据项
+     */
     private void loadDataContent() {
         Cursor c = null;
         mDataList.clear();
@@ -226,13 +366,19 @@ public class SqlNote {
         }
     }
 
+    /**
+     * 从JSON对象设置笔记内容
+     * @param js 包含笔记数据的JSON对象
+     * @return 设置成功返回true，失败返回false
+     */
     public boolean setContent(JSONObject js) {
         try {
             JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
             if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                // 系统文件夹不允许修改
                 Log.w(TAG, "cannot set system folder");
             } 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)) {
@@ -247,6 +393,7 @@ public class SqlNote {
                 }
                 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;
                 if (mIsCreate || mId != id) {
@@ -331,9 +478,11 @@ public class SqlNote {
                 }
                 mOriginParent = originParent;
 
+                // 处理关联的数据项
                 for (int i = 0; i < dataArray.length(); i++) {
                     JSONObject data = dataArray.getJSONObject(i);
                     SqlData sqlData = null;
+                    // 查找是否已存在相同ID的数据项
                     if (data.has(DataColumns.ID)) {
                         long dataId = data.getLong(DataColumns.ID);
                         for (SqlData temp : mDataList) {
@@ -343,11 +492,13 @@ public class SqlNote {
                         }
                     }
 
+                    // 如果不存在，则创建新的数据项
                     if (sqlData == null) {
                         sqlData = new SqlData(mContext);
                         mDataList.add(sqlData);
                     }
 
+                    // 设置数据项内容
                     sqlData.setContent(data);
                 }
             }
@@ -359,17 +510,23 @@ public class SqlNote {
         return true;
     }
 
+    /**
+     * 将笔记内容转换为JSON对象
+     * @return 包含笔记数据的JSON对象，未创建的笔记返回null
+     */
     public JSONObject getContent() {
         try {
             JSONObject js = new JSONObject();
 
             if (mIsCreate) {
+                // 未保存到数据库的笔记无法获取完整内容
                 Log.e(TAG, "it seems that we haven't created this in database yet");
                 return null;
             }
 
             JSONObject note = new JSONObject();
             if (mType == Notes.TYPE_NOTE) {
+                // 普通笔记包含所有属性和关联数据
                 note.put(NoteColumns.ID, mId);
                 note.put(NoteColumns.ALERTED_DATE, mAlertDate);
                 note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@@ -384,6 +541,7 @@ public class SqlNote {
                 note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
 
+                // 添加关联的数据项
                 JSONArray dataArray = new JSONArray();
                 for (SqlData sqlData : mDataList) {
                     JSONObject data = sqlData.getContent();
@@ -393,6 +551,7 @@ public class SqlNote {
                 }
                 js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
             } 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);
@@ -407,47 +566,87 @@ public class SqlNote {
         return null;
     }
 
+    /**
+     * 设置笔记的父文件夹ID
+     * @param id 父文件夹ID
+     */
     public void setParentId(long id) {
         mParentId = id;
         mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
     }
 
+    /**
+     * 设置Google Tasks ID
+     * @param gid Google Tasks ID
+     */
     public void setGtaskId(String gid) {
         mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
     }
 
+    /**
+     * 设置同步ID
+     * @param syncId 同步ID
+     */
     public void setSyncId(long syncId) {
         mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
     }
 
+    /**
+     * 重置本地修改状态
+     * 将本地修改标记设置为0，表示没有本地修改
+     */
     public void resetLocalModified() {
         mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
     }
 
+    /**
+     * 获取笔记ID
+     * @return 笔记ID
+     */
     public long getId() {
         return mId;
     }
 
+    /**
+     * 获取父文件夹ID
+     * @return 父文件夹ID
+     */
     public long getParentId() {
         return mParentId;
     }
 
+    /**
+     * 获取笔记摘要
+     * @return 笔记摘要
+     */
     public String getSnippet() {
         return mSnippet;
     }
 
+    /**
+     * 判断是否为笔记类型
+     * @return 是笔记类型返回true，否则返回false
+     */
     public boolean isNoteType() {
         return mType == Notes.TYPE_NOTE;
     }
 
+    /**
+     * 将笔记提交到数据库
+     * @param validateVersion 是否验证版本号（用于处理并发编辑）
+     */
     public void commit(boolean validateVersion) {
         if (mIsCreate) {
+            // 创建新笔记
+            // 如果ID无效且包含ID字段，则移除该字段（由数据库自动生成）
             if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
                 mDiffNoteValues.remove(NoteColumns.ID);
             }
 
+            // 插入新笔记到数据库
             Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
             try {
+                // 从返回的URI中提取新生成的笔记ID
                 mId = Long.valueOf(uri.getPathSegments().get(1));
             } catch (NumberFormatException e) {
                 Log.e(TAG, "Get note id error :" + e.toString());
@@ -457,25 +656,32 @@ public class SqlNote {
                 throw new IllegalStateException("Create thread id failed");
             }
 
+            // 如果是普通笔记，提交关联的数据项
             if (mType == Notes.TYPE_NOTE) {
                 for (SqlData sqlData : mDataList) {
                     sqlData.commit(mId, false, -1);
                 }
             }
         } else {
+            // 更新现有笔记
+            // 验证笔记ID的有效性（根文件夹和通话记录文件夹是特殊情况）
             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");
             }
+            
+            // 如果有需要更新的字段
             if (mDiffNoteValues.size() > 0) {
-                mVersion ++;
+                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[] {
@@ -487,6 +693,7 @@ public class SqlNote {
                 }
             }
 
+            // 如果是普通笔记，提交关联的数据项
             if (mType == Notes.TYPE_NOTE) {
                 for (SqlData sqlData : mDataList) {
                     sqlData.commit(mId, validateVersion, mVersion);
@@ -494,11 +701,12 @@ public class SqlNote {
             }
         }
 
-        // refresh local info
+        // 刷新本地信息，确保与数据库保持一致
         loadFromCursor(mId);
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
 
+        // 清除差异内容值并标记为已创建
         mDiffNoteValues.clear();
         mIsCreate = false;
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/Task.java b/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
index 6a19454..54df06b 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
@@ -32,64 +32,91 @@ import org.json.JSONException;
 import org.json.JSONObject;
 
 
+/**
+ * Task类 - 表示Google Tasks中的一个任务
+ * 继承自Node类，扩展了任务特定的功能
+ */
 public class Task extends Node {
     private static final String TAG = Task.class.getSimpleName();
 
+    /**
+     * 完成状态 - 标记任务是否已完成
+     */
     private boolean mCompleted;
 
+    /**
+     * 任务备注 - 任务的详细描述或备注信息
+     */
     private String mNotes;
 
+    /**
+     * 元信息 - 包含任务的额外信息的JSON对象
+     */
     private JSONObject mMetaInfo;
 
+    /**
+     * 前一个兄弟任务 - 任务在父列表中的前一个任务
+     */
     private Task mPriorSibling;
 
+    /**
+     * 父任务列表 - 任务所属的任务列表
+     */
     private TaskList mParent;
 
+    /**
+     * 构造函数 - 初始化一个新的任务对象
+     */
     public Task() {
         super();
-        mCompleted = false;
-        mNotes = null;
-        mPriorSibling = null;
-        mParent = null;
-        mMetaInfo = null;
+        mCompleted = false; // 默认未完成
+        mNotes = null; // 默认无备注
+        mPriorSibling = null; // 默认无前一个兄弟任务
+        mParent = null; // 默认无父任务列表
+        mMetaInfo = null; // 默认无元信息
     }
 
+    /**
+     * 获取创建任务的操作JSON对象
+     * @param actionId 操作ID
+     * @return 包含创建任务操作信息的JSON对象
+     */
     public JSONObject getCreateAction(int actionId) {
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+            // 设置操作类型为创建
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
 
-            // action_id
+            // 设置操作ID
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // index
+            // 设置任务在父列表中的索引位置
             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
 
-            // entity_delta
+            // 设置任务实体信息
             JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
-            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务名称
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID
             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
-                    GTaskStringUtils.GTASK_JSON_TYPE_TASK);
+                    GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 实体类型为任务
             if (getNotes() != null) {
-                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 任务备注（如果有）
             }
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
-            // parent_id
+            // 设置父任务列表ID
             js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
 
-            // dest_parent_type
+            // 设置目标父类型为组
             js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
 
-            // list_id
+            // 设置列表ID
             js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
 
-            // prior_sibling_id
+            // 设置前一个兄弟任务ID（如果有）
             if (mPriorSibling != null) {
                 js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
             }
@@ -103,27 +130,32 @@ public class Task extends Node {
         return js;
     }
 
+    /**
+     * 获取更新任务的操作JSON对象
+     * @param actionId 操作ID
+     * @return 包含更新任务操作信息的JSON对象
+     */
     public JSONObject getUpdateAction(int actionId) {
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+            // 设置操作类型为更新
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
 
-            // action_id
+            // 设置操作ID
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // id
+            // 设置任务ID
             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
 
-            // entity_delta
+            // 设置要更新的实体信息
             JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 更新任务名称
             if (getNotes() != null) {
-                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 更新任务备注（如果有）
             }
-            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 更新删除状态
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
         } catch (JSONException e) {
@@ -135,35 +167,39 @@ public class Task extends Node {
         return js;
     }
 
+    /**
+     * 从远程JSON对象设置任务内容
+     * @param js 包含远程任务数据的JSON对象
+     */
     public void setContentByRemoteJSON(JSONObject js) {
         if (js != null) {
             try {
-                // id
+                // 设置任务ID
                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                 }
 
-                // last_modified
+                // 设置最后修改时间
                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                 }
 
-                // name
+                // 设置任务名称
                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                 }
 
-                // notes
+                // 设置任务备注
                 if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
                     setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
                 }
 
-                // deleted
+                // 设置删除状态
                 if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
                     setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
                 }
 
-                // completed
+                // 设置完成状态
                 if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
                     setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
                 }
@@ -175,21 +211,28 @@ public class Task extends Node {
         }
     }
 
+    /**
+     * 从本地JSON对象设置任务内容
+     * @param js 包含本地笔记数据的JSON对象
+     */
     public void setContentByLocalJSON(JSONObject js) {
         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
                 || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+            return;
         }
 
         try {
             JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
             JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
 
+            // 确保是普通笔记类型
             if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
                 Log.e(TAG, "invalid type");
                 return;
             }
 
+            // 查找并设置笔记内容作为任务名称
             for (int i = 0; i < dataArray.length(); i++) {
                 JSONObject data = dataArray.getJSONObject(i);
                 if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
@@ -204,31 +247,37 @@ public class Task extends Node {
         }
     }
 
+    /**
+     * 从任务内容生成本地JSON对象
+     * @return 包含本地笔记数据的JSON对象
+     */
     public JSONObject getLocalJSONFromContent() {
         String name = getName();
         try {
             if (mMetaInfo == null) {
-                // new task created from web
+                // 从网络创建的新任务
                 if (name == null) {
                     Log.w(TAG, "the note seems to be an empty one");
                     return null;
                 }
 
+                // 创建新的JSON对象结构
                 JSONObject js = new JSONObject();
                 JSONObject note = new JSONObject();
                 JSONArray dataArray = new JSONArray();
                 JSONObject data = new JSONObject();
-                data.put(DataColumns.CONTENT, name);
+                data.put(DataColumns.CONTENT, name); // 设置笔记内容为任务名称
                 dataArray.put(data);
-                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
-                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
-                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 添加数据数组
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置笔记类型为普通笔记
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 添加笔记对象
                 return js;
             } else {
-                // synced task
+                // 已同步的任务
                 JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
                 JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
 
+                // 更新笔记内容为当前任务名称
                 for (int i = 0; i < dataArray.length(); i++) {
                     JSONObject data = dataArray.getJSONObject(i);
                     if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
@@ -237,7 +286,7 @@ public class Task extends Node {
                     }
                 }
 
-                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 确保笔记类型为普通笔记
                 return mMetaInfo;
             }
         } catch (JSONException e) {
@@ -247,9 +296,14 @@ public class Task extends Node {
         }
     }
 
+    /**
+     * 设置任务的元信息
+     * @param metaData 包含元信息的MetaData对象
+     */
     public void setMetaInfo(MetaData metaData) {
         if (metaData != null && metaData.getNotes() != null) {
             try {
+                // 从元数据中解析JSON对象
                 mMetaInfo = new JSONObject(metaData.getNotes());
             } catch (JSONException e) {
                 Log.w(TAG, e.toString());
@@ -258,6 +312,11 @@ public class Task extends Node {
         }
     }
 
+    /**
+     * 确定任务的同步操作类型
+     * @param c 包含本地笔记数据的游标
+     * @return 同步操作类型：SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_REMOTE或SYNC_ACTION_ERROR
+     */
     public int getSyncAction(Cursor c) {
         try {
             JSONObject noteInfo = null;
@@ -266,40 +325,43 @@ public class Task extends Node {
             }
 
             if (noteInfo == null) {
+                // 元信息已删除，更新远程
                 Log.w(TAG, "it seems that note meta has been deleted");
                 return SYNC_ACTION_UPDATE_REMOTE;
             }
 
             if (!noteInfo.has(NoteColumns.ID)) {
+                // 远程笔记ID已删除，更新本地
                 Log.w(TAG, "remote note id seems to be deleted");
                 return SYNC_ACTION_UPDATE_LOCAL;
             }
 
-            // validate the note id now
+            // 验证笔记ID
             if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
                 Log.w(TAG, "note id doesn't match");
                 return SYNC_ACTION_UPDATE_LOCAL;
             }
 
             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-                // there is no local update
+                // 本地没有更新
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // no update both side
+                    // 双方都没有更新
                     return SYNC_ACTION_NONE;
                 } else {
-                    // apply remote to local
+                    // 将远程更新应用到本地
                     return SYNC_ACTION_UPDATE_LOCAL;
                 }
             } else {
-                // validate gtask id
+                // 本地有更新，验证Google Tasks ID
                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                     Log.e(TAG, "gtask id doesn't match");
                     return SYNC_ACTION_ERROR;
                 }
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // local modification only
+                    // 只有本地更新
                     return SYNC_ACTION_UPDATE_REMOTE;
                 } else {
+                    // 本地和远程都有更新，存在冲突
                     return SYNC_ACTION_UPDATE_CONFLICT;
                 }
             }
@@ -311,39 +373,75 @@ public class Task extends Node {
         return SYNC_ACTION_ERROR;
     }
 
+    /**
+     * 判断任务是否值得保存
+     * @return 任务有元信息、非空名称或非空备注时返回true，否则返回false
+     */
     public boolean isWorthSaving() {
         return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
                 || (getNotes() != null && getNotes().trim().length() > 0);
     }
 
+    /**
+     * 设置任务的完成状态
+     * @param completed 完成状态
+     */
     public void setCompleted(boolean completed) {
         this.mCompleted = completed;
     }
 
+    /**
+     * 设置任务的备注
+     * @param notes 任务备注
+     */
     public void setNotes(String notes) {
         this.mNotes = notes;
     }
 
+    /**
+     * 设置任务的前一个兄弟任务
+     * @param priorSibling 前一个兄弟任务
+     */
     public void setPriorSibling(Task priorSibling) {
         this.mPriorSibling = priorSibling;
     }
 
+    /**
+     * 设置任务的父任务列表
+     * @param parent 父任务列表
+     */
     public void setParent(TaskList parent) {
         this.mParent = parent;
     }
 
+    /**
+     * 获取任务的完成状态
+     * @return 完成状态
+     */
     public boolean getCompleted() {
         return this.mCompleted;
     }
 
+    /**
+     * 获取任务的备注
+     * @return 任务备注
+     */
     public String getNotes() {
         return this.mNotes;
     }
 
+    /**
+     * 获取任务的前一个兄弟任务
+     * @return 前一个兄弟任务
+     */
     public Task getPriorSibling() {
         return this.mPriorSibling;
     }
 
+    /**
+     * 获取任务的父任务列表
+     * @return 父任务列表
+     */
     public TaskList getParent() {
         return this.mParent;
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java b/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
index 4ea21c5..394ae8a 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
@@ -30,39 +30,57 @@ import org.json.JSONObject;
 import java.util.ArrayList;
 
 
+/**
+ * TaskList类 - 表示Google Tasks中的一个任务列表
+ * 继承自Node类，包含任务列表的基本信息和子任务
+ */
 public class TaskList extends Node {
     private static final String TAG = TaskList.class.getSimpleName();
 
+    /**
+     * 索引 - 任务列表在父容器中的位置
+     */
     private int mIndex;
 
+    /**
+     * 子任务列表 - 存储任务列表中的所有任务
+     */
     private ArrayList<Task> mChildren;
 
+    /**
+     * 构造函数 - 初始化一个新的任务列表对象
+     */
     public TaskList() {
         super();
-        mChildren = new ArrayList<Task>();
-        mIndex = 1;
+        mChildren = new ArrayList<Task>(); // 初始化子任务列表
+        mIndex = 1; // 默认索引为1
     }
 
+    /**
+     * 获取创建任务列表的操作JSON对象
+     * @param actionId 操作ID
+     * @return 包含创建任务列表操作信息的JSON对象
+     */
     public JSONObject getCreateAction(int actionId) {
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+            // 设置操作类型为创建
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
 
-            // action_id
+            // 设置操作ID
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // index
+            // 设置任务列表索引
             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
 
-            // entity_delta
+            // 设置任务列表实体信息
             JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
-            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务列表名称
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID
             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
-                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 实体类型为组
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
         } catch (JSONException e) {
@@ -74,24 +92,29 @@ public class TaskList extends Node {
         return js;
     }
 
+    /**
+     * 获取更新任务列表的操作JSON对象
+     * @param actionId 操作ID
+     * @return 包含更新任务列表操作信息的JSON对象
+     */
     public JSONObject getUpdateAction(int actionId) {
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+            // 设置操作类型为更新
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
 
-            // action_id
+            // 设置操作ID
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // id
+            // 设置任务列表ID
             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
 
-            // entity_delta
+            // 设置要更新的实体信息
             JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
-            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 更新任务列表名称
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 更新删除状态
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
         } catch (JSONException e) {
@@ -103,20 +126,24 @@ public class TaskList extends Node {
         return js;
     }
 
+    /**
+     * 从远程JSON对象设置任务列表内容
+     * @param js 包含远程任务列表数据的JSON对象
+     */
     public void setContentByRemoteJSON(JSONObject js) {
         if (js != null) {
             try {
-                // id
+                // 设置任务列表ID
                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                 }
 
-                // last_modified
+                // 设置最后修改时间
                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                 }
 
-                // name
+                // 设置任务列表名称
                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                 }
@@ -129,18 +156,26 @@ public class TaskList extends Node {
         }
     }
 
+    /**
+     * 从本地JSON对象设置任务列表内容
+     * @param js 包含本地文件夹数据的JSON对象
+     */
     public void setContentByLocalJSON(JSONObject js) {
         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+            return;
         }
 
         try {
             JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
 
+            // 根据本地文件夹类型设置任务列表名称
             if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+                // 普通文件夹，添加前缀
                 String name = folder.getString(NoteColumns.SNIPPET);
                 setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
             } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                // 系统文件夹，根据ID设置不同名称
                 if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
                     setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
                 else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
@@ -157,21 +192,30 @@ public class TaskList extends Node {
         }
     }
 
+    /**
+     * 从任务列表内容生成本地JSON对象
+     * @return 包含本地文件夹数据的JSON对象
+     */
     public JSONObject getLocalJSONFromContent() {
         try {
             JSONObject js = new JSONObject();
             JSONObject folder = new JSONObject();
 
+            // 移除任务列表名称的前缀
             String folderName = getName();
             if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
                 folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
                         folderName.length());
+            
+            // 设置文件夹名称
             folder.put(NoteColumns.SNIPPET, folderName);
+            
+            // 根据名称设置文件夹类型
             if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
                     || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
-                folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+                folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 系统文件夹
             else
-                folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+                folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 普通文件夹
 
             js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
 
@@ -183,28 +227,33 @@ public class TaskList extends Node {
         }
     }
 
+    /**
+     * 确定任务列表的同步操作类型
+     * @param c 包含本地文件夹数据的游标
+     * @return 同步操作类型：SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_REMOTE或SYNC_ACTION_ERROR
+     */
     public int getSyncAction(Cursor c) {
         try {
             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-                // there is no local update
+                // 本地没有更新
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // no update both side
+                    // 双方都没有更新
                     return SYNC_ACTION_NONE;
                 } else {
-                    // apply remote to local
+                    // 将远程更新应用到本地
                     return SYNC_ACTION_UPDATE_LOCAL;
                 }
             } else {
-                // validate gtask id
+                // 本地有更新，验证Google Tasks ID
                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                     Log.e(TAG, "gtask id doesn't match");
                     return SYNC_ACTION_ERROR;
                 }
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // local modification only
+                    // 只有本地更新
                     return SYNC_ACTION_UPDATE_REMOTE;
                 } else {
-                    // for folder conflicts, just apply local modification
+                    // 对于文件夹冲突，直接应用本地修改
                     return SYNC_ACTION_UPDATE_REMOTE;
                 }
             }
@@ -216,16 +265,25 @@ public class TaskList extends Node {
         return SYNC_ACTION_ERROR;
     }
 
+    /**
+     * 获取子任务数量
+     * @return 子任务数量
+     */
     public int getChildTaskCount() {
         return mChildren.size();
     }
 
+    /**
+     * 添加子任务到列表末尾
+     * @param task 要添加的任务
+     * @return 添加成功返回true，失败返回false
+     */
     public boolean addChildTask(Task task) {
         boolean ret = false;
         if (task != null && !mChildren.contains(task)) {
             ret = mChildren.add(task);
             if (ret) {
-                // need to set prior sibling and parent
+                // 设置前一个兄弟任务和父任务
                 task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
                         .get(mChildren.size() - 1));
                 task.setParent(this);
@@ -234,6 +292,12 @@ public class TaskList extends Node {
         return ret;
     }
 
+    /**
+     * 在指定位置添加子任务
+     * @param task 要添加的任务
+     * @param index 添加位置的索引
+     * @return 添加成功返回true，失败返回false
+     */
     public boolean addChildTask(Task task, int index) {
         if (index < 0 || index > mChildren.size()) {
             Log.e(TAG, "add child task: invalid index");
@@ -244,7 +308,7 @@ public class TaskList extends Node {
         if (task != null && pos == -1) {
             mChildren.add(index, task);
 
-            // update the task list
+            // 更新任务列表的兄弟关系
             Task preTask = null;
             Task afterTask = null;
             if (index != 0)
@@ -260,6 +324,11 @@ public class TaskList extends Node {
         return true;
     }
 
+    /**
+     * 移除子任务
+     * @param task 要移除的任务
+     * @return 移除成功返回true，失败返回false
+     */
     public boolean removeChildTask(Task task) {
         boolean ret = false;
         int index = mChildren.indexOf(task);
@@ -267,11 +336,11 @@ public class TaskList extends Node {
             ret = mChildren.remove(task);
 
             if (ret) {
-                // reset prior sibling and parent
+                // 重置前一个兄弟任务和父任务
                 task.setPriorSibling(null);
                 task.setParent(null);
 
-                // update the task list
+                // 更新任务列表的兄弟关系
                 if (index != mChildren.size()) {
                     mChildren.get(index).setPriorSibling(
                             index == 0 ? null : mChildren.get(index - 1));
@@ -281,8 +350,13 @@ public class TaskList extends Node {
         return ret;
     }
 
+    /**
+     * 移动子任务到新位置
+     * @param task 要移动的任务
+     * @param index 新位置的索引
+     * @return 移动成功返回true，失败返回false
+     */
     public boolean moveChildTask(Task task, int index) {
-
         if (index < 0 || index >= mChildren.size()) {
             Log.e(TAG, "move child task: invalid index");
             return false;
@@ -299,6 +373,11 @@ public class TaskList extends Node {
         return (removeChildTask(task) && addChildTask(task, index));
     }
 
+    /**
+     * 根据Google Tasks ID查找子任务
+     * @param gid Google Tasks ID
+     * @return 找到的任务，未找到返回null
+     */
     public Task findChildTaskByGid(String gid) {
         for (int i = 0; i < mChildren.size(); i++) {
             Task t = mChildren.get(i);
@@ -309,10 +388,20 @@ public class TaskList extends Node {
         return null;
     }
 
+    /**
+     * 获取子任务在列表中的索引位置
+     * @param task 子任务
+     * @return 子任务的索引位置
+     */
     public int getChildTaskIndex(Task task) {
         return mChildren.indexOf(task);
     }
 
+    /**
+     * 根据索引位置获取子任务
+     * @param index 索引位置
+     * @return 找到的任务，索引无效返回null
+     */
     public Task getChildTaskByIndex(int index) {
         if (index < 0 || index >= mChildren.size()) {
             Log.e(TAG, "getTaskByIndex: invalid index");
@@ -321,6 +410,11 @@ public class TaskList extends Node {
         return mChildren.get(index);
     }
 
+    /**
+     * 根据Google Tasks ID获取子任务
+     * @param gid Google Tasks ID
+     * @return 找到的任务，未找到返回null
+     */
     public Task getChilTaskByGid(String gid) {
         for (Task task : mChildren) {
             if (task.getGid().equals(gid))
@@ -329,14 +423,26 @@ public class TaskList extends Node {
         return null;
     }
 
+    /**
+     * 获取所有子任务的列表
+     * @return 子任务列表
+     */
     public ArrayList<Task> getChildTaskList() {
         return this.mChildren;
     }
 
+    /**
+     * 设置任务列表的索引
+     * @param index 索引值
+     */
     public void setIndex(int index) {
         this.mIndex = index;
     }
 
+    /**
+     * 获取任务列表的索引
+     * @return 索引值
+     */
     public int getIndex() {
         return this.mIndex;
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java b/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
index 15504be..caaf20f 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
@@ -16,17 +16,33 @@
 
 package net.micode.notes.gtask.exception;
 
+/**
+ * 操作失败异常类，用于表示Google Tasks同步操作失败的情况
+ */
 public class ActionFailureException extends RuntimeException {
+    /** 序列化版本UID */
     private static final long serialVersionUID = 4425249765923293627L;
 
+    /**
+     * 默认构造方法
+     */
     public ActionFailureException() {
         super();
     }
 
+    /**
+     * 带错误消息的构造方法
+     * @param paramString 错误消息
+     */
     public ActionFailureException(String paramString) {
         super(paramString);
     }
 
+    /**
+     * 带错误消息和原因的构造方法
+     * @param paramString 错误消息
+     * @param paramThrowable 异常原因
+     */
     public ActionFailureException(String paramString, Throwable paramThrowable) {
         super(paramString, paramThrowable);
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java b/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
index b08cfb1..cb07b99 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
@@ -16,17 +16,33 @@
 
 package net.micode.notes.gtask.exception;
 
+/**
+ * 网络失败异常类，用于表示Google Tasks同步过程中网络连接失败的情况
+ */
 public class NetworkFailureException extends Exception {
+    /** 序列化版本UID */
     private static final long serialVersionUID = 2107610287180234136L;
 
+    /**
+     * 默认构造方法
+     */
     public NetworkFailureException() {
         super();
     }
 
+    /**
+     * 带错误消息的构造方法
+     * @param paramString 错误消息
+     */
     public NetworkFailureException(String paramString) {
         super(paramString);
     }
 
+    /**
+     * 带错误消息和原因的构造方法
+     * @param paramString 错误消息
+     * @param paramThrowable 异常原因
+     */
     public NetworkFailureException(String paramString, Throwable paramThrowable) {
         super(paramString, paramThrowable);
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
index 85a789b..5993ad1 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
@@ -29,22 +29,51 @@ import net.micode.notes.ui.NotesListActivity;
 import net.micode.notes.ui.NotesPreferenceActivity;
 
 
+/**
+ * GTaskASyncTask类 - 用于在后台执行Google Tasks同步操作的异步任务
+ */
 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
 
+    /**
+     * 同步通知ID常量 - 用于标识Google Tasks同步通知
+     */
     private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
 
+    /**
+     * OnCompleteListener接口 - 同步完成时的回调接口
+     */
     public interface OnCompleteListener {
+        /**
+         * 同步完成时调用
+         */
         void onComplete();
     }
 
+    /**
+     * 上下文对象 - 用于访问系统服务和资源
+     */
     private Context mContext;
 
+    /**
+     * 通知管理器 - 用于显示同步通知
+     */
     private NotificationManager mNotifiManager;
 
+    /**
+     * 任务管理器 - 用于执行实际的同步操作
+     */
     private GTaskManager mTaskManager;
 
+    /**
+     * 完成监听器 - 同步完成时的回调对象
+     */
     private OnCompleteListener mOnCompleteListener;
 
+    /**
+     * 构造函数 - 初始化Google Tasks异步任务
+     * @param context 上下文对象
+     * @param listener 同步完成时的回调监听器
+     */
     public GTaskASyncTask(Context context, OnCompleteListener listener) {
         mContext = context;
         mOnCompleteListener = listener;
@@ -53,10 +82,17 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         mTaskManager = GTaskManager.getInstance();
     }
 
+    /**
+     * 取消同步操作
+     */
     public void cancelSync() {
         mTaskManager.cancelSync();
     }
 
+    /**
+     * 发布同步进度
+     * @param message 进度消息
+     */
     public void publishProgess(String message) {
         publishProgress(new String[] {
             message
@@ -81,24 +117,32 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
     //            pendingIntent);
     //    mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
     //}
+    /**
+     * 显示同步通知
+     * @param tickerId 通知标题的字符串资源ID
+     * @param content 通知内容
+     */
     private void showNotification(int tickerId, String content) {
         PendingIntent pendingIntent;
         if (tickerId != R.string.ticker_success) {
+            // 同步失败时，点击通知跳转到设置页面
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
                     NotesPreferenceActivity.class), PendingIntent.FLAG_IMMUTABLE);
         } else {
+            // 同步成功时，点击通知跳转到笔记列表页面
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
                     NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE);
         }
+        // 创建通知构建器
         Notification.Builder builder = new Notification.Builder(mContext)
-                .setAutoCancel(true)
-                .setContentTitle(mContext.getString(R.string.app_name))
-                .setContentText(content)
-                .setContentIntent(pendingIntent)
-                .setWhen(System.currentTimeMillis())
-                .setOngoing(true);
+                .setAutoCancel(true) // 点击后自动取消通知
+                .setContentTitle(mContext.getString(R.string.app_name)) // 设置通知标题
+                .setContentText(content) // 设置通知内容
+                .setContentIntent(pendingIntent) // 设置点击通知时的跳转意图
+                .setWhen(System.currentTimeMillis()) // 设置通知时间
+                .setOngoing(true); // 设置为持续通知
         Notification notification=builder.getNotification();
-        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
+        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); // 显示通知
     }
 
 
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
index c67dfdf..4da77b3 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
@@ -61,35 +61,44 @@ import java.util.zip.Inflater;
 import java.util.zip.InflaterInputStream;
 
 
+/**
+ * Google Tasks客户端类
+ * 实现与Google Tasks API的通信，处理任务和任务列表的CRUD操作
+ * 使用单例模式确保全局只有一个实例
+ */
 public class GTaskClient {
-    private static final String TAG = GTaskClient.class.getSimpleName();
+    private static final String TAG = GTaskClient.class.getSimpleName();  // 日志标签
 
-    private static final String GTASK_URL = "https://mail.google.com/tasks/";
+    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";
+    private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";  // Google Tasks GET请求URL
 
-    private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
+    private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";  // Google Tasks POST请求URL
 
-    private static GTaskClient mInstance = null;
+    private static GTaskClient mInstance = null;  // 单例实例
 
-    private DefaultHttpClient mHttpClient;
+    private DefaultHttpClient mHttpClient;  // HTTP客户端实例
 
-    private String mGetUrl;
+    private String mGetUrl;  // 当前使用的GET请求URL
 
-    private String mPostUrl;
+    private String mPostUrl;  // 当前使用的POST请求URL
 
-    private long mClientVersion;
+    private long mClientVersion;  // 客户端版本号
 
-    private boolean mLoggedin;
+    private boolean mLoggedin;  // 登录状态标识
 
-    private long mLastLoginTime;
+    private long mLastLoginTime;  // 最后登录时间
 
-    private int mActionId;
+    private int mActionId;  // 操作ID计数器
 
-    private Account mAccount;
+    private Account mAccount;  // Google账户
 
-    private JSONArray mUpdateArray;
+    private JSONArray mUpdateArray;  // 更新操作数组，用于批量提交更新
 
+    /**
+     * 私有构造函数 - 初始化客户端实例
+     * 单例模式确保外部无法直接创建实例
+     */
     private GTaskClient() {
         mHttpClient = null;
         mGetUrl = GTASK_GET_URL;
@@ -102,6 +111,11 @@ public class GTaskClient {
         mUpdateArray = null;
     }
 
+    /**
+     * 获取GTaskClient的单例实例
+     * 使用同步方法确保线程安全
+     * @return GTaskClient单例实例
+     */
     public static synchronized GTaskClient getInstance() {
         if (mInstance == null) {
             mInstance = new GTaskClient();
@@ -109,6 +123,13 @@ public class GTaskClient {
         return mInstance;
     }
 
+    /**
+     * 登录Google Tasks服务
+     * 如果已经登录且会话未过期，则直接返回true
+     * 否则重新登录Google账户并建立与Google Tasks的连接
+     * @param activity 调用该方法的Activity实例，用于获取账户信息
+     * @return 是否登录成功
+     */
     public boolean login(Activity activity) {
         // we suppose that the cookie would expire after 5 minutes
         // then we need to re-login
@@ -164,6 +185,12 @@ public class GTaskClient {
         return true;
     }
 
+    /**
+     * 登录Google账户并获取认证令牌
+     * @param activity 调用该方法的Activity实例，用于获取账户信息
+     * @param invalidateToken 是否使当前令牌无效并重新获取
+     * @return 认证令牌，如果获取失败则返回null
+     */
     private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
         String authToken;
         AccountManager accountManager = AccountManager.get(activity);
@@ -207,6 +234,13 @@ public class GTaskClient {
         return authToken;
     }
 
+    /**
+     * 尝试使用认证令牌登录Google Tasks服务
+     * 如果第一次登录失败，会尝试重新获取令牌并再次登录
+     * @param activity 调用该方法的Activity实例，用于重新获取令牌
+     * @param authToken 认证令牌
+     * @return 是否登录成功
+     */
     private boolean tryToLoginGtask(Activity activity, String authToken) {
         if (!loginGtask(authToken)) {
             // maybe the auth token is out of date, now let's invalidate the
@@ -225,6 +259,12 @@ public class GTaskClient {
         return true;
     }
 
+    /**
+     * 使用认证令牌登录Google Tasks服务
+     * 配置HTTP客户端，设置超时时间，发送登录请求并处理响应
+     * @param authToken 认证令牌
+     * @return 是否登录成功
+     */
     private boolean loginGtask(String authToken) {
         int timeoutConnection = 10000;
         int timeoutSocket = 15000;
@@ -280,10 +320,20 @@ public class GTaskClient {
         return true;
     }
 
+    /**
+     * 获取唯一的操作ID
+     * 每次调用都会递增操作ID计数器
+     * @return 新的操作ID
+     */
     private int getActionId() {
         return mActionId++;
     }
 
+    /**
+     * 创建HTTP POST请求对象
+     * 设置请求URL和必要的请求头
+     * @return 配置好的HttpPost对象
+     */
     private HttpPost createHttpPost() {
         HttpPost httpPost = new HttpPost(mPostUrl);
         httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
@@ -291,6 +341,13 @@ public class GTaskClient {
         return httpPost;
     }
 
+    /**
+     * 获取HTTP响应内容
+     * 支持gzip和deflate压缩格式，自动解压并返回字符串内容
+     * @param entity HTTP响应实体
+     * @return 响应内容字符串
+     * @throws IOException 如果读取响应内容失败
+     */
     private String getResponseContent(HttpEntity entity) throws IOException {
         String contentEncoding = null;
         if (entity.getContentEncoding() != null) {
@@ -323,6 +380,14 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 发送POST请求到Google Tasks API
+     * 封装JSON数据并发送请求，处理响应并返回JSON对象
+     * @param js 要发送的JSON对象
+     * @return 响应的JSON对象
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果请求处理失败
+     */
     private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
         if (!mLoggedin) {
             Log.e(TAG, "please login first");
@@ -360,6 +425,13 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 创建新的Google Tasks任务
+     * 提交更新并发送创建任务的请求，处理响应并更新任务的GID
+     * @param task 要创建的任务对象
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果创建任务失败
+     */
     public void createTask(Task task) throws NetworkFailureException {
         commitUpdate();
         try {
@@ -386,6 +458,13 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 创建新的Google Tasks任务列表
+     * 提交更新并发送创建任务列表的请求，处理响应并更新任务列表的GID
+     * @param tasklist 要创建的任务列表对象
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果创建任务列表失败
+     */
     public void createTaskList(TaskList tasklist) throws NetworkFailureException {
         commitUpdate();
         try {
@@ -412,6 +491,12 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 提交更新到Google Tasks服务器
+     * 将mUpdateArray中的所有更新操作批量发送到服务器
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果更新处理失败
+     */
     public void commitUpdate() throws NetworkFailureException {
         if (mUpdateArray != null) {
             try {
@@ -433,6 +518,12 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 将节点添加到更新数组中
+     * 当更新数组超过10个元素时，会自动提交更新
+     * @param node 要添加的节点对象
+     * @throws NetworkFailureException 如果提交更新时网络请求失败
+     */
     public void addUpdateNode(Node node) throws NetworkFailureException {
         if (node != null) {
             // too many update items may result in an error
@@ -447,6 +538,15 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 移动任务位置
+     * 可以在同一个任务列表内移动任务，也可以将任务从一个任务列表移动到另一个任务列表
+     * @param task 要移动的任务对象
+     * @param preParent 移动前的父任务列表
+     * @param curParent 移动后的父任务列表
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果移动任务失败
+     */
     public void moveTask(Task task, TaskList preParent, TaskList curParent)
             throws NetworkFailureException {
         commitUpdate();
@@ -486,6 +586,13 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 删除节点
+     * 将节点标记为已删除并发送删除请求到Google Tasks服务器
+     * @param node 要删除的节点对象
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果删除节点失败
+     */
     public void deleteNode(Node node) throws NetworkFailureException {
         commitUpdate();
         try {
@@ -509,6 +616,13 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 获取所有任务列表
+     * 从Google Tasks服务器获取所有任务列表信息
+     * @return 任务列表的JSON数组
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果获取任务列表失败
+     */
     public JSONArray getTaskLists() throws NetworkFailureException {
         if (!mLoggedin) {
             Log.e(TAG, "please login first");
@@ -547,6 +661,14 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 获取指定任务列表中的所有任务
+     * 从Google Tasks服务器获取指定任务列表的所有任务信息
+     * @param listGid 任务列表的GID
+     * @return 任务的JSON数组
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果获取任务失败
+     */
     public JSONArray getTaskList(String listGid) throws NetworkFailureException {
         commitUpdate();
         try {
@@ -575,10 +697,18 @@ public class GTaskClient {
         }
     }
 
+    /**
+     * 获取当前同步的Google账户
+     * @return 当前同步的Account对象
+     */
     public Account getSyncAccount() {
         return mAccount;
     }
 
+    /**
+     * 重置更新数组
+     * 清空mUpdateArray中的所有更新操作
+     */
     public void resetUpdateArray() {
         mUpdateArray = null;
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
index d2b4082..0b8cee5 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
@@ -48,45 +48,45 @@ import java.util.Iterator;
 import java.util.Map;
 
 
+/**
+ * Google Tasks同步管理器类
+ * 负责处理本地笔记与Google Tasks之间的同步逻辑
+ * 实现单例模式，管理同步状态和同步操作
+ */
 public class GTaskManager {
-    private static final String TAG = GTaskManager.class.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;
-
-    private Activity mActivity;
-
-    private Context mContext;
-
-    private ContentResolver mContentResolver;
-
-    private boolean mSyncing;
-
-    private boolean mCancelled;
-
-    private HashMap<String, TaskList> mGTaskListHashMap;
-
-    private HashMap<String, Node> mGTaskHashMap;
-
-    private HashMap<String, MetaData> mMetaHashMap;
-
-    private TaskList mMetaList;
-
-    private HashSet<Long> mLocalDeleteIdMap;
-
-    private HashMap<String, Long> mGidToNid;
-
-    private HashMap<Long, String> mNidToGid;
-
+    private static final String TAG = GTaskManager.class.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;           // 单例实例
+
+    private Activity mActivity;                             // 用于获取认证令牌的Activity实例
+    private Context mContext;                               // 应用上下文
+    private ContentResolver mContentResolver;               // 内容解析器，用于访问本地数据库
+
+    private boolean mSyncing;                               // 同步状态标志
+    private boolean mCancelled;                             // 同步取消标志
+
+    // Google Tasks数据结构映射
+    private HashMap<String, TaskList> mGTaskListHashMap;    // Google任务列表映射
+    private HashMap<String, Node> mGTaskHashMap;            // Google任务节点映射
+    private HashMap<String, MetaData> mMetaHashMap;         // 元数据映射
+    private TaskList mMetaList;                             // 元数据任务列表
+
+    // 同步辅助数据结构
+    private HashSet<Long> mLocalDeleteIdMap;                // 本地删除的笔记ID集合
+    private HashMap<String, Long> mGidToNid;                // Google任务ID到本地笔记ID的映射
+    private HashMap<Long, String> mNidToGid;                // 本地笔记ID到Google任务ID的映射
+
+    /**
+     * 私有构造函数 - 初始化同步管理器实例
+     * 初始化所有同步相关的数据结构和状态标志
+     */
     private GTaskManager() {
         mSyncing = false;
         mCancelled = false;
@@ -99,6 +99,11 @@ public class GTaskManager {
         mNidToGid = new HashMap<Long, String>();
     }
 
+    /**
+     * 获取GTaskManager的单例实例
+     * 使用同步方法确保线程安全
+     * @return GTaskManager单例实例
+     */
     public static synchronized GTaskManager getInstance() {
         if (mInstance == null) {
             mInstance = new GTaskManager();
@@ -106,11 +111,28 @@ public class GTaskManager {
         return mInstance;
     }
 
+    /**
+     * 设置Activity上下文
+     * 用于后续获取Google认证令牌
+     * @param activity 用于获取认证令牌的Activity实例
+     */
     public synchronized void setActivityContext(Activity activity) {
         // used for getting authtoken
         mActivity = activity;
     }
 
+    /**
+     * 执行笔记与Google Tasks之间的同步操作
+     * 这是GTaskManager的核心方法，协调整个同步流程
+     * @param context 应用上下文
+     * @param asyncTask 异步任务实例，用于发布同步进度
+     * @return 同步状态码：
+     *         STATE_SUCCESS - 同步成功
+     *         STATE_NETWORK_ERROR - 网络错误
+     *         STATE_INTERNAL_ERROR - 内部错误
+     *         STATE_SYNC_IN_PROGRESS - 同步进行中
+     *         STATE_SYNC_CANCELLED - 同步已取消
+     */
     public int sync(Context context, GTaskASyncTask asyncTask) {
         if (mSyncing) {
             Log.d(TAG, "Sync is in progress");
@@ -168,6 +190,13 @@ public class GTaskManager {
         return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
     }
 
+    /**
+     * 初始化Google Tasks列表
+     * 从Google服务器获取所有任务列表和任务数据，并构建本地映射
+     * 处理元数据任务列表，确保其存在
+     * @throws NetworkFailureException 如果网络请求失败
+     * @throws ActionFailureException 如果处理JSON数据失败
+     */
     private void initGTaskList() throws NetworkFailureException {
         if (mCancelled)
             return;
@@ -247,6 +276,18 @@ public class GTaskManager {
         }
     }
 
+    /**
+     * 同步内容
+     * 处理本地和Google Tasks之间的内容同步
+     * 包括：
+     * 1. 处理本地已删除的笔记
+     * 2. 同步文件夹
+     * 3. 处理本地已存在的笔记
+     * 4. 处理Google端新增的内容
+     * 5. 清理本地删除的笔记
+     * 6. 刷新本地同步ID
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void syncContent() throws NetworkFailureException {
         int syncType;
         Cursor c = null;
@@ -351,6 +392,16 @@ public class GTaskManager {
 
     }
 
+    /**
+     * 同步文件夹
+     * 处理本地和Google Tasks之间的文件夹同步
+     * 包括：
+     * 1. 同步根文件夹
+     * 2. 同步通话记录文件夹
+     * 3. 同步本地已存在的普通文件夹
+     * 4. 同步Google端新增的文件夹
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void syncFolder() throws NetworkFailureException {
         Cursor c = null;
         String gid;
@@ -476,6 +527,21 @@ public class GTaskManager {
             GTaskClient.getInstance().commitUpdate();
     }
 
+    /**
+     * 执行内容同步操作
+     * 根据同步类型执行不同的同步动作
+     * @param syncType 同步类型：
+     *                 Node.SYNC_ACTION_ADD_LOCAL - 本地添加
+     *                 Node.SYNC_ACTION_ADD_REMOTE - 远程添加
+     *                 Node.SYNC_ACTION_DEL_LOCAL - 本地删除
+     *                 Node.SYNC_ACTION_DEL_REMOTE - 远程删除
+     *                 Node.SYNC_ACTION_UPDATE_LOCAL - 本地更新
+     *                 Node.SYNC_ACTION_UPDATE_REMOTE - 远程更新
+     *                 Node.SYNC_ACTION_UPDATE_CONFLICT - 更新冲突
+     * @param node 要同步的节点
+     * @param c 本地数据库游标
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -522,6 +588,12 @@ public class GTaskManager {
         }
     }
 
+    /**
+     * 添加本地节点
+     * 将Google Tasks中的节点添加到本地数据库
+     * @param node 要添加的Google Tasks节点
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void addLocalNode(Node node) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -596,6 +668,13 @@ public class GTaskManager {
         updateRemoteMeta(node.getGid(), sqlNote);
     }
 
+    /**
+     * 更新本地节点
+     * 使用Google Tasks中的节点信息更新本地数据库中的笔记
+     * @param node Google Tasks中的节点信息
+     * @param c 本地数据库游标
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -619,6 +698,13 @@ public class GTaskManager {
         updateRemoteMeta(node.getGid(), sqlNote);
     }
 
+    /**
+     * 添加远程节点
+     * 将本地数据库中的笔记添加到Google Tasks
+     * @param node Google Tasks节点（可能为null）
+     * @param c 本地数据库游标
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -692,6 +778,14 @@ public class GTaskManager {
         mNidToGid.put(sqlNote.getId(), n.getGid());
     }
 
+    /**
+     * 更新远程节点
+     * 将本地数据库中笔记的更新同步到Google Tasks
+     * 如果需要，还会处理任务的移动（更改父文件夹）
+     * @param node Google Tasks节点
+     * @param c 本地数据库游标
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -730,6 +824,13 @@ public class GTaskManager {
         sqlNote.commit(true);
     }
 
+    /**
+     * 更新远程元数据
+     * 将本地笔记的元数据信息更新到Google Tasks的元数据列表中
+     * @param gid Google Tasks节点ID
+     * @param sqlNote 本地笔记对象
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
         if (sqlNote != null && sqlNote.isNoteType()) {
             MetaData metaData = mMetaHashMap.get(gid);
@@ -746,6 +847,12 @@ public class GTaskManager {
         }
     }
 
+    /**
+     * 刷新本地同步ID
+     * 同步完成后，更新本地笔记的同步ID为Google Tasks的最后修改时间
+     * 确保下次同步时能正确检测到更改
+     * @throws NetworkFailureException 如果网络请求失败
+     */
     private void refreshLocalSyncId() throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -790,10 +897,18 @@ public class GTaskManager {
         }
     }
 
+    /**
+     * 获取当前同步账户
+     * @return 当前用于Google Tasks同步的账户名称
+     */
     public String getSyncAccount() {
         return GTaskClient.getInstance().getSyncAccount().name;
     }
 
+    /**
+     * 取消当前同步操作
+     * 设置取消标志，使正在进行的同步操作能够优雅地终止
+     */
     public void cancelSync() {
         mCancelled = true;
     }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
index cca36f7..cb82eb6 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
@@ -23,25 +23,33 @@ import android.content.Intent;
 import android.os.Bundle;
 import android.os.IBinder;
 
+/**
+ * Google Tasks同步服务
+ * 管理Google Tasks与本地笔记之间的同步操作的Service组件
+ * 提供开始同步、取消同步的功能，并通过广播通知同步状态和进度
+ */
 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 = "";
-
+    // 动作类型常量定义
+    public final static String ACTION_STRING_NAME = "sync_action_type";  // 动作类型的Intent额外数据键
+
+    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";  // 广播的Intent动作名称
+    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 = "";           // 当前同步进度消息
+
+    /**
+     * 启动同步操作
+     * 创建并执行Google Tasks同步异步任务
+     * 如果已经有同步任务在执行，则不重复启动
+     */
     private void startSync() {
         if (mSyncTask == null) {
             mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@@ -56,6 +64,10 @@ public class GTaskSyncService extends Service {
         }
     }
 
+    /**
+     * 取消同步操作
+     * 如果有同步任务正在执行，则取消该任务
+     */
     private void cancelSync() {
         if (mSyncTask != null) {
             mSyncTask.cancelSync();
@@ -64,11 +76,13 @@ public class GTaskSyncService extends Service {
 
     @Override
     public void onCreate() {
+        // 服务创建时初始化同步任务为null
         mSyncTask = null;
     }
 
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
+        // 处理传入的Intent，根据动作类型执行相应的同步操作
         Bundle bundle = intent.getExtras();
         if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
             switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
@@ -81,6 +95,7 @@ public class GTaskSyncService extends Service {
                 default:
                     break;
             }
+            // 返回START_STICKY表示如果服务被系统杀死，会在资源允许时重新创建
             return START_STICKY;
         }
         return super.onStartCommand(intent, flags, startId);
@@ -88,15 +103,28 @@ public class GTaskSyncService extends Service {
 
     @Override
     public void onLowMemory() {
+        // 系统内存不足时，如果有同步任务正在执行，则取消它以释放资源
         if (mSyncTask != null) {
             mSyncTask.cancelSync();
         }
     }
 
+    /**
+     * Service的绑定方法
+     * 该服务不支持绑定，因此返回null
+     * @param intent 绑定意图
+     * @return null
+     */
+    @Override
     public IBinder onBind(Intent intent) {
         return null;
     }
 
+    /**
+     * 发送同步状态广播
+     * 通知应用其他组件同步的当前状态和进度
+     * @param msg 同步进度消息
+     */
     public void sendBroadcast(String msg) {
         mSyncProgress = msg;
         Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@@ -105,6 +133,11 @@ public class GTaskSyncService extends Service {
         sendBroadcast(intent);
     }
 
+    /**
+     * 静态方法：启动Google Tasks同步服务
+     * 这是启动同步的公共入口方法，设置Activity上下文并发送启动同步的Intent
+     * @param activity 用于获取Google认证的Activity实例
+     */
     public static void startSync(Activity activity) {
         GTaskManager.getInstance().setActivityContext(activity);
         Intent intent = new Intent(activity, GTaskSyncService.class);
@@ -112,16 +145,29 @@ public class GTaskSyncService extends Service {
         activity.startService(intent);
     }
 
+    /**
+     * 静态方法：取消Google Tasks同步服务
+     * 这是取消同步的公共入口方法，发送取消同步的Intent
+     * @param context 应用上下文
+     */
     public static void cancelSync(Context context) {
         Intent intent = new Intent(context, GTaskSyncService.class);
         intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
         context.startService(intent);
     }
 
+    /**
+     * 静态方法：检查是否正在同步
+     * @return true表示正在同步，false表示未在同步
+     */
     public static boolean isSyncing() {
         return mSyncTask != null;
     }
 
+    /**
+     * 静态方法：获取当前同步进度消息
+     * @return 当前同步进度消息字符串
+     */
     public static String getProgressString() {
         return mSyncProgress;
     }
diff --git a/src/Notes-master/src/net/micode/notes/model/Note.java b/src/Notes-master/src/net/micode/notes/model/Note.java
index 6706cf6..d3b5180 100644
--- a/src/Notes-master/src/net/micode/notes/model/Note.java
+++ b/src/Notes-master/src/net/micode/notes/model/Note.java
@@ -34,15 +34,24 @@ import net.micode.notes.data.Notes.TextNote;
 import java.util.ArrayList;
 
 
+/**
+ * 笔记模型类
+ * 用于处理笔记的创建、更新和同步操作
+ * 采用分层设计，将笔记的元数据和具体内容分开管理
+ */
 public class Note {
-    private ContentValues mNoteDiffValues;
-    private NoteData mNoteData;
-    private static final String TAG = "Note";
+    private ContentValues mNoteDiffValues;  // 存储笔记的差异值，用于增量更新
+    private NoteData mNoteData;              // 存储笔记的具体数据（文本、通话等）
+    private static final String TAG = "Note";  // 日志标签
     /**
-     * Create a new note id for adding a new note to databases
+     * 创建一个新笔记并返回其ID
+     * 用于向数据库中添加新笔记
+     * @param context 上下文对象
+     * @param folderId 新笔记所属的文件夹ID
+     * @return 新创建的笔记ID
      */
     public static synchronized long getNewNoteId(Context context, long folderId) {
-        // Create a new note in the database
+        // 创建一个新笔记在数据库中
         ContentValues values = new ContentValues();
         long createdTime = System.currentTimeMillis();
         values.put(NoteColumns.CREATED_DATE, createdTime);
@@ -65,41 +74,82 @@ public class Note {
         return noteId;
     }
 
+    /**
+     * 构造方法 - 初始化笔记对象
+     */
     public Note() {
         mNoteDiffValues = new ContentValues();
         mNoteData = new NoteData();
     }
 
+    /**
+     * 设置笔记的元数据值
+     * @param key 字段名
+     * @param value 字段值
+     */
     public void setNoteValue(String key, String value) {
         mNoteDiffValues.put(key, value);
         mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
         mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
     }
 
+    /**
+     * 设置文本笔记的数据
+     * @param key 字段名
+     * @param value 字段值
+     */
     public void setTextData(String key, String value) {
         mNoteData.setTextData(key, value);
     }
 
+    /**
+     * 设置文本笔记的数据ID
+     * @param id 文本笔记数据ID
+     */
     public void setTextDataId(long id) {
         mNoteData.setTextDataId(id);
     }
 
+    /**
+     * 获取文本笔记的数据ID
+     * @return 文本笔记数据ID
+     */
     public long getTextDataId() {
         return mNoteData.mTextDataId;
     }
 
+    /**
+     * 设置通话笔记的数据ID
+     * @param id 通话笔记数据ID
+     */
     public void setCallDataId(long id) {
         mNoteData.setCallDataId(id);
     }
 
+    /**
+     * 设置通话笔记的数据
+     * @param key 字段名
+     * @param value 字段值
+     */
     public void setCallData(String key, String value) {
         mNoteData.setCallData(key, value);
     }
 
+    /**
+     * 检查笔记是否在本地被修改
+     * @return 如果笔记在本地被修改，返回true，否则返回false
+     */
     public boolean isLocalModified() {
         return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
     }
 
+    /**
+     * 同步笔记到数据库
+     * 将本地修改的笔记数据同步到数据库中
+     * @param context 上下文对象
+     * @param noteId 要同步的笔记ID
+     * @return 同步是否成功
+     */
     public boolean syncNote(Context context, long noteId) {
         if (noteId <= 0) {
             throw new IllegalArgumentException("Wrong note id:" + noteId);
@@ -130,17 +180,20 @@ public class Note {
         return true;
     }
 
+    /**
+     * 笔记数据内部类
+     * 用于管理笔记的具体内容数据，支持文本笔记和通话笔记
+     */
     private class NoteData {
-        private long mTextDataId;
-
-        private ContentValues mTextDataValues;
-
-        private long mCallDataId;
-
-        private ContentValues mCallDataValues;
-
-        private static final String TAG = "NoteData";
+        private long mTextDataId;      // 文本笔记数据ID
+        private ContentValues mTextDataValues;  // 文本笔记数据值
+        private long mCallDataId;      // 通话笔记数据ID
+        private ContentValues mCallDataValues;  // 通话笔记数据值
+        private static final String TAG = "NoteData";  // 日志标签
 
+        /**
+         * 构造方法 - 初始化笔记数据对象
+         */
         public NoteData() {
             mTextDataValues = new ContentValues();
             mCallDataValues = new ContentValues();
@@ -148,10 +201,19 @@ public class Note {
             mCallDataId = 0;
         }
 
+        /**
+         * 检查笔记数据是否在本地被修改
+         * @return 如果笔记数据在本地被修改，返回true，否则返回false
+         */
         boolean isLocalModified() {
             return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
         }
 
+        /**
+         * 设置文本笔记的数据ID
+         * @param id 文本笔记数据ID
+         * @throws IllegalArgumentException 如果ID小于等于0
+         */
         void setTextDataId(long id) {
             if(id <= 0) {
                 throw new IllegalArgumentException("Text data id should larger than 0");
@@ -159,6 +221,11 @@ public class Note {
             mTextDataId = id;
         }
 
+        /**
+         * 设置通话笔记的数据ID
+         * @param id 通话笔记数据ID
+         * @throws IllegalArgumentException 如果ID小于等于0
+         */
         void setCallDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Call data id should larger than 0");
@@ -166,18 +233,35 @@ public class Note {
             mCallDataId = id;
         }
 
+        /**
+         * 设置通话笔记的数据
+         * @param key 字段名
+         * @param value 字段值
+         */
         void setCallData(String key, String value) {
             mCallDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
+        /**
+         * 设置文本笔记的数据
+         * @param key 字段名
+         * @param value 字段值
+         */
         void setTextData(String key, String value) {
             mTextDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
+        /**
+         * 将笔记数据推入内容解析器
+         * 将本地修改的笔记数据同步到数据库中
+         * @param context 上下文对象
+         * @param noteId 笔记ID
+         * @return 同步后的URI，同步失败返回null
+         */
         Uri pushIntoContentResolver(Context context, long noteId) {
             /**
              * Check for safety
diff --git a/src/Notes-master/src/net/micode/notes/model/WorkingNote.java b/src/Notes-master/src/net/micode/notes/model/WorkingNote.java
index be081e4..6801af8 100644
--- a/src/Notes-master/src/net/micode/notes/model/WorkingNote.java
+++ b/src/Notes-master/src/net/micode/notes/model/WorkingNote.java
@@ -32,76 +32,73 @@ import net.micode.notes.data.Notes.TextNote;
 import net.micode.notes.tool.ResourceParser.NoteBgResources;
 
 
+/**
+ * 工作笔记类
+ * 用于在用户界面层管理笔记的编辑状态和操作
+ * 封装了笔记的数据模型和用户交互相关的逻辑
+ */
 public class WorkingNote {
-    // Note for the working note
-    private Note mNote;
-    // Note Id
-    private long mNoteId;
-    // Note content
-    private String mContent;
-    // Note mode
-    private int mMode;
-
-    private long mAlertDate;
-
-    private long mModifiedDate;
-
-    private int mBgColorId;
-
-    private int mWidgetId;
-
-    private int mWidgetType;
-
-    private long mFolderId;
-
-    private Context mContext;
-
-    private static final String TAG = "WorkingNote";
-
-    private boolean mIsDeleted;
-
-    private NoteSettingChangedListener mNoteSettingStatusListener;
-
+    private Note mNote;                          // 实际的笔记数据模型
+    private long mNoteId;                        // 笔记ID
+    private String mContent;                     // 笔记内容
+    private int mMode;                           // 笔记模式（普通模式/清单模式）
+    private long mAlertDate;                     // 提醒日期时间
+    private long mModifiedDate;                  // 最后修改时间
+    private int mBgColorId;                      // 背景颜色ID
+    private int mWidgetId;                       // 小部件ID
+    private int mWidgetType;                     // 小部件类型
+    private long mFolderId;                      // 所属文件夹ID
+    private Context mContext;                    // 上下文对象
+    private static final String TAG = "WorkingNote";  // 日志标签
+    private boolean mIsDeleted;                  // 是否已删除
+    private NoteSettingChangedListener mNoteSettingStatusListener;  // 笔记设置变化监听器
+
+    /**
+     * 笔记数据查询投影列
+     * 用于查询笔记的详细内容数据
+     */
     public static final String[] DATA_PROJECTION = new String[] {
-            DataColumns.ID,
-            DataColumns.CONTENT,
-            DataColumns.MIME_TYPE,
-            DataColumns.DATA1,
-            DataColumns.DATA2,
-            DataColumns.DATA3,
-            DataColumns.DATA4,
+            DataColumns.ID,           // 数据ID
+            DataColumns.CONTENT,      // 笔记内容
+            DataColumns.MIME_TYPE,    // 数据类型
+            DataColumns.DATA1,        // 附加数据1
+            DataColumns.DATA2,        // 附加数据2
+            DataColumns.DATA3,        // 附加数据3
+            DataColumns.DATA4,        // 附加数据4
     };
 
+    /**
+     * 笔记元数据查询投影列
+     * 用于查询笔记的基本信息
+     */
     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
+            NoteColumns.PARENT_ID,     // 所属文件夹ID
+            NoteColumns.ALERTED_DATE,  // 提醒日期
+            NoteColumns.BG_COLOR_ID,   // 背景颜色ID
+            NoteColumns.WIDGET_ID,     // 小部件ID
+            NoteColumns.WIDGET_TYPE,   // 小部件类型
+            NoteColumns.MODIFIED_DATE  // 修改日期
     };
 
-    private static final int DATA_ID_COLUMN = 0;
-
-    private static final int DATA_CONTENT_COLUMN = 1;
-
-    private static final int DATA_MIME_TYPE_COLUMN = 2;
-
-    private static final int DATA_MODE_COLUMN = 3;
-
-    private static final int NOTE_PARENT_ID_COLUMN = 0;
-
-    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
-
-    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
-
-    private static final int NOTE_WIDGET_ID_COLUMN = 3;
-
-    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
-
-    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
-
-    // New note construct
+    // 数据查询结果列索引
+    private static final int DATA_ID_COLUMN = 0;                // 数据ID列索引
+    private static final int DATA_CONTENT_COLUMN = 1;           // 内容列索引
+    private static final int DATA_MIME_TYPE_COLUMN = 2;         // MIME类型列索引
+    private static final int DATA_MODE_COLUMN = 3;              // 模式列索引
+
+    // 笔记查询结果列索引
+    private static final int NOTE_PARENT_ID_COLUMN = 0;         // 父文件夹ID列索引
+    private static final int NOTE_ALERTED_DATE_COLUMN = 1;      // 提醒日期列索引
+    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;       // 背景颜色ID列索引
+    private static final int NOTE_WIDGET_ID_COLUMN = 3;         // 小部件ID列索引
+    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;       // 小部件类型列索引
+    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;     // 修改日期列索引
+
+    /**
+     * 构造方法 - 创建新笔记
+     * @param context 上下文对象
+     * @param folderId 所属文件夹ID
+     */
     private WorkingNote(Context context, long folderId) {
         mContext = context;
         mAlertDate = 0;
@@ -114,7 +111,12 @@ public class WorkingNote {
         mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
     }
 
-    // Existing note construct
+    /**
+     * 构造方法 - 加载现有笔记
+     * @param context 上下文对象
+     * @param noteId 笔记ID
+     * @param folderId 所属文件夹ID
+     */
     private WorkingNote(Context context, long noteId, long folderId) {
         mContext = context;
         mNoteId = noteId;
@@ -124,6 +126,10 @@ public class WorkingNote {
         loadNote();
     }
 
+    /**
+     * 从数据库加载笔记信息
+     * 加载笔记的元数据，如文件夹ID、提醒日期、背景颜色等
+     */
     private void loadNote() {
         Cursor cursor = mContext.getContentResolver().query(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
@@ -146,6 +152,10 @@ public class WorkingNote {
         loadNoteData();
     }
 
+    /**
+     * 从数据库加载笔记内容数据
+     * 加载笔记的实际内容和相关数据类型信息
+     */
     private void loadNoteData() {
         Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
                 DataColumns.NOTE_ID + "=?", new String[] {
@@ -174,6 +184,15 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 创建空笔记
+     * @param context 上下文对象
+     * @param folderId 所属文件夹ID
+     * @param widgetId 小部件ID
+     * @param widgetType 小部件类型
+     * @param defaultBgColorId 默认背景颜色ID
+     * @return 新创建的空工作笔记对象
+     */
     public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
             int widgetType, int defaultBgColorId) {
         WorkingNote note = new WorkingNote(context, folderId);
@@ -183,10 +202,20 @@ public class WorkingNote {
         return note;
     }
 
+    /**
+     * 从数据库加载指定ID的笔记
+     * @param context 上下文对象
+     * @param id 笔记ID
+     * @return 加载的工作笔记对象
+     */
     public static WorkingNote load(Context context, long id) {
         return new WorkingNote(context, id, 0);
     }
 
+    /**
+     * 保存笔记到数据库
+     * @return 是否保存成功
+     */
     public synchronized boolean saveNote() {
         if (isWorthSaving()) {
             if (!existInDatabase()) {
@@ -212,10 +241,19 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 检查笔记是否存在于数据库中
+     * @return 如果笔记已存在于数据库中返回true，否则返回false
+     */
     public boolean existInDatabase() {
         return mNoteId > 0;
     }
 
+    /**
+     * 检查笔记是否值得保存
+     * 当笔记已删除、空内容且不存在于数据库中、或存在于数据库但未被修改时，不值得保存
+     * @return 如果笔记值得保存返回true，否则返回false
+     */
     private boolean isWorthSaving() {
         if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
                 || (existInDatabase() && !mNote.isLocalModified())) {
@@ -225,10 +263,19 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置笔记设置变化监听器
+     * @param l 监听器对象
+     */
     public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
         mNoteSettingStatusListener = l;
     }
 
+    /**
+     * 设置笔记提醒日期
+     * @param date 提醒日期时间
+     * @param set 是否设置提醒
+     */
     public void setAlertDate(long date, boolean set) {
         if (date != mAlertDate) {
             mAlertDate = date;
@@ -239,6 +286,10 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 标记笔记为已删除或未删除
+     * @param mark 是否标记为已删除
+     */
     public void markDeleted(boolean mark) {
         mIsDeleted = mark;
         if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@@ -247,6 +298,10 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置笔记背景颜色ID
+     * @param id 背景颜色ID
+     */
     public void setBgColorId(int id) {
         if (id != mBgColorId) {
             mBgColorId = id;
@@ -257,6 +312,10 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置笔记模式（普通模式/清单模式）
+     * @param mode 模式类型
+     */
     public void setCheckListMode(int mode) {
         if (mMode != mode) {
             if (mNoteSettingStatusListener != null) {
@@ -267,6 +326,10 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置笔记小部件类型
+     * @param type 小部件类型
+     */
     public void setWidgetType(int type) {
         if (type != mWidgetType) {
             mWidgetType = type;
@@ -274,6 +337,10 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置笔记小部件ID
+     * @param id 小部件ID
+     */
     public void setWidgetId(int id) {
         if (id != mWidgetId) {
             mWidgetId = id;
@@ -281,6 +348,10 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置笔记工作内容
+     * @param text 笔记内容
+     */
     public void setWorkingText(String text) {
         if (!TextUtils.equals(mContent, text)) {
             mContent = text;
@@ -288,80 +359,139 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 将笔记转换为通话记录笔记
+     * @param phoneNumber 电话号码
+     * @param callDate 通话日期时间
+     */
     public void convertToCallNote(String phoneNumber, long callDate) {
         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));
     }
 
+    /**
+     * 检查笔记是否设置了提醒
+     * @return 如果设置了提醒返回true，否则返回false
+     */
     public boolean hasClockAlert() {
         return (mAlertDate > 0 ? true : false);
     }
 
+    /**
+     * 获取笔记内容
+     * @return 笔记内容
+     */
     public String getContent() {
         return mContent;
     }
 
+    /**
+     * 获取笔记提醒日期
+     * @return 提醒日期时间
+     */
     public long getAlertDate() {
         return mAlertDate;
     }
 
+    /**
+     * 获取笔记最后修改时间
+     * @return 最后修改时间
+     */
     public long getModifiedDate() {
         return mModifiedDate;
     }
 
+    /**
+     * 获取笔记背景颜色资源ID
+     * @return 背景颜色资源ID
+     */
     public int getBgColorResId() {
         return NoteBgResources.getNoteBgResource(mBgColorId);
     }
 
+    /**
+     * 获取笔记背景颜色ID
+     * @return 背景颜色ID
+     */
     public int getBgColorId() {
         return mBgColorId;
     }
 
+    /**
+     * 获取笔记标题背景资源ID
+     * @return 标题背景资源ID
+     */
     public int getTitleBgResId() {
         return NoteBgResources.getNoteTitleBgResource(mBgColorId);
     }
 
+    /**
+     * 获取笔记模式（普通模式/清单模式）
+     * @return 笔记模式
+     */
     public int getCheckListMode() {
         return mMode;
     }
 
+    /**
+     * 获取笔记ID
+     * @return 笔记ID
+     */
     public long getNoteId() {
         return mNoteId;
     }
 
+    /**
+     * 获取笔记所属文件夹ID
+     * @return 文件夹ID
+     */
     public long getFolderId() {
         return mFolderId;
     }
 
+    /**
+     * 获取笔记小部件ID
+     * @return 小部件ID
+     */
     public int getWidgetId() {
         return mWidgetId;
     }
 
+    /**
+     * 获取笔记小部件类型
+     * @return 小部件类型
+     */
     public int getWidgetType() {
         return mWidgetType;
     }
 
+    /**
+     * 笔记设置变化监听器
+     * 用于监听笔记设置变化事件
+     */
     public interface NoteSettingChangedListener {
         /**
-         * Called when the background color of current note has just changed
+         * 当笔记背景颜色改变时调用
          */
         void onBackgroundColorChanged();
 
         /**
-         * Called when user set clock
+         * 当用户设置或取消提醒时调用
+         * @param date 提醒日期时间
+         * @param set 是否设置提醒
          */
         void onClockAlertChanged(long date, boolean set);
 
         /**
-         * Call when user create note from widget
+         * 当笔记小部件内容需要更新时调用
          */
         void onWidgetChanged();
 
         /**
-         * Call when switch between check list mode and normal mode
-         * @param oldMode is previous mode before change
-         * @param newMode is new mode
+         * 当切换笔记模式（普通模式/清单模式）时调用
+         * @param oldMode 切换前的模式
+         * @param newMode 切换后的模式
          */
         void onCheckListModeChanged(int oldMode, int newMode);
     }
diff --git a/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java b/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
index 39f6ec4..1a1db63 100644
--- a/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
+++ b/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
@@ -36,11 +36,20 @@ import java.io.IOException;
 import java.io.PrintStream;
 
 
+/**
+ * 备份工具类 - 用于将笔记数据导出为文本文件
+ * 采用单例模式设计，确保全局只有一个备份工具实例
+ */
 public class BackupUtils {
-    private static final String TAG = "BackupUtils";
+    private static final String TAG = "BackupUtils";  // 日志标签
     // Singleton stuff
-    private static BackupUtils sInstance;
+    private static BackupUtils sInstance;  // 单例实例
 
+    /**
+     * 获取BackupUtils单例实例
+     * @param context 上下文对象
+     * @return BackupUtils单例实例
+     */
     public static synchronized BackupUtils getInstance(Context context) {
         if (sInstance == null) {
             sInstance = new BackupUtils(context);
@@ -53,78 +62,106 @@ public class BackupUtils {
      * status
      */
     // Currently, the sdcard is not mounted
-    public static final int STATE_SD_CARD_UNMOUONTED           = 0;
+    public static final int STATE_SD_CARD_UNMOUONTED           = 0;  // SD卡未挂载
     // The backup file not exist
-    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;
+    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;  // 备份文件不存在
     // The data is not well formated, may be changed by other programs
-    public static final int STATE_DATA_DESTROIED               = 2;
+    public static final int STATE_DATA_DESTROIED               = 2;  // 数据格式错误
     // Some run-time exception which causes restore or backup fails
-    public static final int STATE_SYSTEM_ERROR                 = 3;
+    public static final int STATE_SYSTEM_ERROR                 = 3;  // 系统错误
     // Backup or restore success
-    public static final int STATE_SUCCESS                      = 4;
+    public static final int STATE_SUCCESS                      = 4;  // 操作成功
 
-    private TextExport mTextExport;
+    private TextExport mTextExport;  // 文本导出工具实例
 
+    /**
+     * 私有构造方法 - 初始化文本导出工具
+     * @param context 上下文对象
+     */
     private BackupUtils(Context context) {
         mTextExport = new TextExport(context);
     }
 
+    /**
+     * 检查外部存储是否可用
+     * @return 外部存储是否可用
+     */
     private static boolean externalStorageAvailable() {
         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
     }
 
+    /**
+     * 将笔记导出为文本文件
+     * @return 导出状态码
+     */
     public int exportToText() {
         return mTextExport.exportToText();
     }
 
+    /**
+     * 获取导出的文本文件名
+     * @return 导出的文本文件名
+     */
     public String getExportedTextFileName() {
         return mTextExport.mFileName;
     }
 
+    /**
+     * 获取导出的文本文件目录
+     * @return 导出的文本文件目录
+     */
     public String getExportedTextFileDir() {
         return mTextExport.mFileDirectory;
     }
 
+    /**
+     * 文本导出工具类 - 负责将笔记数据转换为文本格式并保存到文件
+     */
     private static class TextExport {
+        // 笔记查询投影列
         private static final String[] NOTE_PROJECTION = {
-                NoteColumns.ID,
-                NoteColumns.MODIFIED_DATE,
-                NoteColumns.SNIPPET,
-                NoteColumns.TYPE
+                NoteColumns.ID,               // 笔记ID
+                NoteColumns.MODIFIED_DATE,    // 修改日期
+                NoteColumns.SNIPPET,          // 笔记摘要
+                NoteColumns.TYPE              // 笔记类型
         };
 
-        private static final int NOTE_COLUMN_ID = 0;
-
-        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
-
-        private static final int NOTE_COLUMN_SNIPPET = 2;
+        // 笔记查询结果列索引
+        private static final int NOTE_COLUMN_ID = 0;                // ID列索引
+        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;     // 修改日期列索引
+        private static final int NOTE_COLUMN_SNIPPET = 2;           // 摘要列索引
 
+        // 笔记数据查询投影列
         private static final String[] DATA_PROJECTION = {
-                DataColumns.CONTENT,
-                DataColumns.MIME_TYPE,
-                DataColumns.DATA1,
-                DataColumns.DATA2,
-                DataColumns.DATA3,
-                DataColumns.DATA4,
+                DataColumns.CONTENT,          // 内容
+                DataColumns.MIME_TYPE,        // MIME类型
+                DataColumns.DATA1,            // 数据1
+                DataColumns.DATA2,            // 数据2
+                DataColumns.DATA3,            // 数据3
+                DataColumns.DATA4,            // 数据4
         };
 
-        private static final int DATA_COLUMN_CONTENT = 0;
-
-        private static final int DATA_COLUMN_MIME_TYPE = 1;
-
-        private static final int DATA_COLUMN_CALL_DATE = 2;
-
-        private static final int DATA_COLUMN_PHONE_NUMBER = 4;
+        // 笔记数据查询结果列索引
+        private static final int DATA_COLUMN_CONTENT = 0;           // 内容列索引
+        private static final int DATA_COLUMN_MIME_TYPE = 1;         // MIME类型列索引
+        private static final int DATA_COLUMN_CALL_DATE = 2;         // 通话日期列索引
+        private static final int DATA_COLUMN_PHONE_NUMBER = 4;      // 电话号码列索引
 
+        // 文本格式模板
         private final String [] TEXT_FORMAT;
-        private static final int FORMAT_FOLDER_NAME          = 0;
-        private static final int FORMAT_NOTE_DATE            = 1;
-        private static final int FORMAT_NOTE_CONTENT         = 2;
+        private static final int FORMAT_FOLDER_NAME          = 0;    // 文件夹名称格式
+        private static final int FORMAT_NOTE_DATE            = 1;    // 笔记日期格式
+        private static final int FORMAT_NOTE_CONTENT         = 2;    // 笔记内容格式
 
-        private Context mContext;
-        private String mFileName;
-        private String mFileDirectory;
+        // 成员变量
+        private Context mContext;           // 上下文对象
+        private String mFileName;           // 导出文件名
+        private String mFileDirectory;      // 导出文件目录
 
+        /**
+         * 构造方法 - 初始化文本导出工具
+         * @param context 上下文对象
+         */
         public TextExport(Context context) {
             TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
             mContext = context;
@@ -132,15 +169,22 @@ public class BackupUtils {
             mFileDirectory = "";
         }
 
+        /**
+         * 获取指定ID的文本格式模板
+         * @param id 格式模板ID
+         * @return 文本格式模板
+         */
         private String getFormat(int id) {
             return TEXT_FORMAT[id];
         }
 
         /**
-         * Export the folder identified by folder id to text
+         * 将指定ID的文件夹及其包含的笔记导出为文本格式
+         * @param folderId 文件夹ID
+         * @param ps 输出流对象
          */
         private void exportFolderToText(String folderId, PrintStream ps) {
-            // Query notes belong to this folder
+            // 查询该文件夹下的所有笔记
             Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
                         folderId
@@ -149,11 +193,11 @@ public class BackupUtils {
             if (notesCursor != null) {
                 if (notesCursor.moveToFirst()) {
                     do {
-                        // Print note's last modified date
+                        // 打印笔记的最后修改日期
                         ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                 mContext.getString(R.string.format_datetime_mdhm),
                                 notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // Query data belong to this note
+                        // 查询该笔记的详细数据
                         String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                         exportNoteToText(noteId, ps);
                     } while (notesCursor.moveToNext());
@@ -163,9 +207,12 @@ public class BackupUtils {
         }
 
         /**
-         * Export note identified by id to a print stream
+         * 将指定ID的笔记导出到输出流中
+         * @param noteId 笔记ID
+         * @param ps 输出流对象
          */
         private void exportNoteToText(String noteId, PrintStream ps) {
+            // 查询该笔记的详细数据
             Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
                     DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
                         noteId
@@ -175,26 +222,29 @@ public class BackupUtils {
                 if (dataCursor.moveToFirst()) {
                     do {
                         String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
+                        // 处理通话记录类型笔记
                         if (DataConstants.CALL_NOTE.equals(mimeType)) {
-                            // Print phone number
                             String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
                             long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
                             String location = dataCursor.getString(DATA_COLUMN_CONTENT);
 
+                            // 打印电话号码
                             if (!TextUtils.isEmpty(phoneNumber)) {
                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                         phoneNumber));
                             }
-                            // Print call date
+                            // 打印通话日期
                             ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
                                     .format(mContext.getString(R.string.format_datetime_mdhm),
                                             callDate)));
-                            // Print call attachment location
+                            // 打印通话附件位置
                             if (!TextUtils.isEmpty(location)) {
                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                         location));
                             }
-                        } else if (DataConstants.NOTE.equals(mimeType)) {
+                        } 
+                        // 处理普通类型笔记
+                        else if (DataConstants.NOTE.equals(mimeType)) {
                             String content = dataCursor.getString(DATA_COLUMN_CONTENT);
                             if (!TextUtils.isEmpty(content)) {
                                 ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
@@ -205,10 +255,10 @@ public class BackupUtils {
                 }
                 dataCursor.close();
             }
-            // print a line separator between note
+            // 在笔记之间打印分隔符
             try {
                 ps.write(new byte[] {
-                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
+                        Character.LINE_SEPARATOR, Character.LINE_SEPARATOR
                 });
             } catch (IOException e) {
                 Log.e(TAG, e.toString());
@@ -216,20 +266,24 @@ public class BackupUtils {
         }
 
         /**
-         * Note will be exported as text which is user readable
+         * 将所有笔记导出为用户可读的文本格式
+         * @return 导出状态码
          */
         public int exportToText() {
+            // 检查外部存储是否可用
             if (!externalStorageAvailable()) {
                 Log.d(TAG, "Media was not mounted");
                 return STATE_SD_CARD_UNMOUONTED;
             }
 
+            // 获取输出流
             PrintStream ps = getExportToTextPrintStream();
             if (ps == null) {
                 Log.e(TAG, "get print stream error");
                 return STATE_SYSTEM_ERROR;
             }
-            // First export folder and its notes
+            
+            // 首先导出文件夹及其包含的笔记
             Cursor folderCursor = mContext.getContentResolver().query(
                     Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION,
@@ -240,8 +294,9 @@ public class BackupUtils {
             if (folderCursor != null) {
                 if (folderCursor.moveToFirst()) {
                     do {
-                        // Print folder's name
+                        // 打印文件夹名称
                         String folderName = "";
+                        // 特殊处理通话记录文件夹
                         if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
                             folderName = mContext.getString(R.string.call_record_folder_name);
                         } else {
@@ -250,6 +305,8 @@ public class BackupUtils {
                         if (!TextUtils.isEmpty(folderName)) {
                             ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
                         }
+                        
+                        // 导出该文件夹下的所有笔记
                         String folderId = folderCursor.getString(NOTE_COLUMN_ID);
                         exportFolderToText(folderId, ps);
                     } while (folderCursor.moveToNext());
@@ -257,7 +314,7 @@ public class BackupUtils {
                 folderCursor.close();
             }
 
-            // Export notes in root's folder
+            // 导出根目录下的笔记
             Cursor noteCursor = mContext.getContentResolver().query(
                     Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION,
@@ -267,33 +324,42 @@ public class BackupUtils {
             if (noteCursor != null) {
                 if (noteCursor.moveToFirst()) {
                     do {
+                        // 打印笔记修改日期
                         ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                 mContext.getString(R.string.format_datetime_mdhm),
                                 noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // Query data belong to this note
+                        // 导出笔记内容
                         String noteId = noteCursor.getString(NOTE_COLUMN_ID);
                         exportNoteToText(noteId, ps);
                     } while (noteCursor.moveToNext());
                 }
                 noteCursor.close();
             }
+            
+            // 关闭输出流
             ps.close();
 
             return STATE_SUCCESS;
         }
 
         /**
-         * Get a print stream pointed to the file {@generateExportedTextFile}
+         * 获取指向导出文本文件的输出流
+         * @return 输出流对象，失败则返回null
          */
         private PrintStream getExportToTextPrintStream() {
+            // 生成导出文件
             File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
                     R.string.file_name_txt_format);
             if (file == null) {
                 Log.e(TAG, "create file to exported failed");
                 return null;
             }
+            
+            // 保存文件名和目录信息
             mFileName = file.getName();
             mFileDirectory = mContext.getString(R.string.file_path);
+            
+            // 创建输出流
             PrintStream ps = null;
             try {
                 FileOutputStream fos = new FileOutputStream(file);
@@ -310,19 +376,27 @@ public class BackupUtils {
     }
 
     /**
-     * Generate the text file to store imported data
+     * 在SD卡上生成用于存储导出数据的文本文件
+     * @param context 上下文对象
+     * @param filePathResId 文件路径资源ID
+     * @param fileNameFormatResId 文件名格式资源ID
+     * @return 创建的文件对象，失败则返回null
      */
     private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
         StringBuilder sb = new StringBuilder();
+        // 构建文件路径：SD卡根目录 + 自定义路径
         sb.append(Environment.getExternalStorageDirectory());
         sb.append(context.getString(filePathResId));
         File filedir = new File(sb.toString());
+        
+        // 构建完整文件名：路径 + 格式化文件名（包含当前日期）
         sb.append(context.getString(
                 fileNameFormatResId,
                 DateFormat.format(context.getString(R.string.format_date_ymd),
                         System.currentTimeMillis())));
         File file = new File(sb.toString());
 
+        // 创建目录和文件
         try {
             if (!filedir.exists()) {
                 filedir.mkdir();
diff --git a/src/Notes-master/src/net/micode/notes/tool/DataUtils.java b/src/Notes-master/src/net/micode/notes/tool/DataUtils.java
index 2a14982..9e6edca 100644
--- a/src/Notes-master/src/net/micode/notes/tool/DataUtils.java
+++ b/src/Notes-master/src/net/micode/notes/tool/DataUtils.java
@@ -35,8 +35,21 @@ import java.util.ArrayList;
 import java.util.HashSet;
 
 
+/**
+ * 数据工具类 - 提供笔记数据的各种操作工具方法
+ * 包含批量删除、移动笔记、文件夹管理、小部件处理等功能
+ */
 public class DataUtils {
+    /**
+     * 日志标签
+     */
     public static final String TAG = "DataUtils";
+    /**
+     * 批量删除笔记
+     * @param resolver 内容解析器
+     * @param ids 要删除的笔记ID集合
+     * @return 是否删除成功
+     */
     public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
         if (ids == null) {
             Log.d(TAG, "the ids is null");
@@ -72,6 +85,13 @@ public class DataUtils {
         return false;
     }
 
+    /**
+     * 将单个笔记从源文件夹移动到目标文件夹
+     * @param resolver 内容解析器
+     * @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();
         values.put(NoteColumns.PARENT_ID, desFolderId);
@@ -80,6 +100,13 @@ public class DataUtils {
         resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
     }
 
+    /**
+     * 批量将笔记移动到指定文件夹
+     * @param resolver 内容解析器
+     * @param ids 要移动的笔记ID集合
+     * @param folderId 目标文件夹ID
+     * @return 是否移动成功
+     */
     public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
             long folderId) {
         if (ids == null) {
@@ -112,7 +139,9 @@ public class DataUtils {
     }
 
     /**
-     * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
+     * 获取用户创建的文件夹数量（不包括系统文件夹）
+     * @param resolver 内容解析器
+     * @return 用户文件夹数量
      */
     public static int getUserFolderCount(ContentResolver resolver) {
         Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
@@ -136,6 +165,13 @@ public class DataUtils {
         return count;
     }
 
+    /**
+     * 检查指定ID和类型的笔记是否在数据库中可见（不在垃圾桶中）
+     * @param resolver 内容解析器
+     * @param noteId 笔记ID
+     * @param type 笔记类型
+     * @return 是否可见
+     */
     public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null,
@@ -153,6 +189,12 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查指定ID的笔记是否存在于数据库中
+     * @param resolver 内容解析器
+     * @param noteId 笔记ID
+     * @return 是否存在
+     */
     public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null, null, null, null);
@@ -167,6 +209,12 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查指定ID的笔记数据是否存在于数据库中
+     * @param resolver 内容解析器
+     * @param dataId 数据ID
+     * @return 是否存在
+     */
     public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
                 null, null, null, null);
@@ -181,6 +229,12 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查指定名称的可见文件夹是否存在（不在垃圾桶中）
+     * @param resolver 内容解析器
+     * @param name 文件夹名称
+     * @return 是否存在
+     */
     public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
                 NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
@@ -197,6 +251,12 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 获取与指定文件夹关联的所有应用小部件
+     * @param resolver 内容解析器
+     * @param folderId 文件夹ID
+     * @return 应用小部件属性集合
+     */
     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 },
@@ -224,6 +284,13 @@ public class DataUtils {
         return set;
     }
 
+    /**
+     * 通过笔记ID获取电话号码
+     * 用于通话记录笔记的电话号码获取
+     * @param resolver 内容解析器
+     * @param noteId 笔记ID
+     * @return 电话号码
+     */
     public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.PHONE_NUMBER },
@@ -243,6 +310,14 @@ public class DataUtils {
         return "";
     }
 
+    /**
+     * 通过电话号码和通话日期获取笔记ID
+     * 用于通话记录笔记的查询
+     * @param resolver 内容解析器
+     * @param phoneNumber 电话号码
+     * @param callDate 通话日期时间戳
+     * @return 笔记ID
+     */
     public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.NOTE_ID },
@@ -264,6 +339,13 @@ public class DataUtils {
         return 0;
     }
 
+    /**
+     * 通过笔记ID获取笔记摘要
+     * @param resolver 内容解析器
+     * @param noteId 笔记ID
+     * @return 笔记摘要
+     * @throws IllegalArgumentException 如果笔记不存在
+     */
     public static String getSnippetById(ContentResolver resolver, long noteId) {
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
                 new String [] { NoteColumns.SNIPPET },
@@ -282,6 +364,12 @@ public class DataUtils {
         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();
diff --git a/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java b/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
index 666b729..4e58fd5 100644
--- a/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
+++ b/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
@@ -16,98 +16,285 @@
 
 package net.micode.notes.tool;
 
+/**
+ * Google Tasks字符串工具类 - 定义Google Tasks同步相关的所有字符串常量
+ * 包含JSON字段名、操作类型、文件夹名称等用于Google Tasks API交互和本地数据处理的常量
+ */
 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_TYPE_GROUP = "GROUP";
 
+
+    /**
+     * JSON字段：类型 - 任务
+     */
     public final static String GTASK_JSON_TYPE_TASK = "TASK";
 
+
+    /**
+     * 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 Tasks 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";
 
 }
diff --git a/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java b/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
index 1ad3ad6..423c5e5 100644
--- a/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
+++ b/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
@@ -22,24 +22,76 @@ import android.preference.PreferenceManager;
 import net.micode.notes.R;
 import net.micode.notes.ui.NotesPreferenceActivity;
 
+/**
+ * 资源解析工具类 - 管理笔记应用的UI资源
+ * 包括背景资源、字体大小、小部件资源等
+ */
 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;
 
+    /**
+     * 笔记编辑背景资源类
+     * 管理笔记编辑界面的背景资源
+     */
     public static class NoteBgResources {
+        /**
+         * 笔记编辑主背景资源数组
+         * 索引对应背景颜色常量
+         */
         private final static int [] BG_EDIT_RESOURCES = new int [] {
             R.drawable.edit_yellow,
             R.drawable.edit_blue,
@@ -48,6 +100,10 @@ public class ResourceParser {
             R.drawable.edit_red
         };
 
+        /**
+         * 笔记编辑标题栏背景资源数组
+         * 索引对应背景颜色常量
+         */
         private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
             R.drawable.edit_title_yellow,
             R.drawable.edit_title_blue,
@@ -56,15 +112,31 @@ public class ResourceParser {
             R.drawable.edit_title_red
         };
 
+        /**
+         * 获取笔记编辑主背景资源
+         * @param id 背景颜色ID
+         * @return 背景资源ID
+         */
         public static int getNoteBgResource(int id) {
             return BG_EDIT_RESOURCES[id];
         }
 
+        /**
+         * 获取笔记编辑标题栏背景资源
+         * @param id 背景颜色ID
+         * @return 标题栏背景资源ID
+         */
         public static int getNoteTitleBgResource(int id) {
             return BG_EDIT_TITLE_RESOURCES[id];
         }
     }
 
+    /**
+     * 获取默认背景颜色ID
+     * 根据用户偏好设置决定是使用随机颜色还是默认颜色
+     * @param context 上下文
+     * @return 背景颜色ID
+     */
     public static int getDefaultBgId(Context context) {
         if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
                 NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
@@ -74,7 +146,15 @@ public class ResourceParser {
         }
     }
 
+    /**
+     * 笔记列表项背景资源类
+     * 管理笔记列表中不同位置项的背景资源
+     */
     public static class NoteItemBgResources {
+        /**
+         * 列表首项背景资源数组
+         * 索引对应背景颜色常量
+         */
         private final static int [] BG_FIRST_RESOURCES = new int [] {
             R.drawable.list_yellow_up,
             R.drawable.list_blue_up,
@@ -83,6 +163,10 @@ public class ResourceParser {
             R.drawable.list_red_up
         };
 
+        /**
+         * 列表中间项背景资源数组
+         * 索引对应背景颜色常量
+         */
         private final static int [] BG_NORMAL_RESOURCES = new int [] {
             R.drawable.list_yellow_middle,
             R.drawable.list_blue_middle,
@@ -91,6 +175,10 @@ public class ResourceParser {
             R.drawable.list_red_middle
         };
 
+        /**
+         * 列表末项背景资源数组
+         * 索引对应背景颜色常量
+         */
         private final static int [] BG_LAST_RESOURCES = new int [] {
             R.drawable.list_yellow_down,
             R.drawable.list_blue_down,
@@ -99,6 +187,10 @@ public class ResourceParser {
             R.drawable.list_red_down,
         };
 
+        /**
+         * 列表单项背景资源数组
+         * 索引对应背景颜色常量
+         */
         private final static int [] BG_SINGLE_RESOURCES = new int [] {
             R.drawable.list_yellow_single,
             R.drawable.list_blue_single,
@@ -107,28 +199,60 @@ public class ResourceParser {
             R.drawable.list_red_single
         };
 
+        /**
+         * 获取列表首项背景资源
+         * @param id 背景颜色ID
+         * @return 首项背景资源ID
+         */
         public static int getNoteBgFirstRes(int id) {
             return BG_FIRST_RESOURCES[id];
         }
 
+        /**
+         * 获取列表末项背景资源
+         * @param id 背景颜色ID
+         * @return 末项背景资源ID
+         */
         public static int getNoteBgLastRes(int id) {
             return BG_LAST_RESOURCES[id];
         }
 
+        /**
+         * 获取列表单项背景资源
+         * @param id 背景颜色ID
+         * @return 单项背景资源ID
+         */
         public static int getNoteBgSingleRes(int id) {
             return BG_SINGLE_RESOURCES[id];
         }
 
+        /**
+         * 获取列表中间项背景资源
+         * @param id 背景颜色ID
+         * @return 中间项背景资源ID
+         */
         public static int getNoteBgNormalRes(int id) {
             return BG_NORMAL_RESOURCES[id];
         }
 
+        /**
+         * 获取文件夹项背景资源
+         * @return 文件夹背景资源ID
+         */
         public static int getFolderBgRes() {
             return R.drawable.list_folder;
         }
     }
 
+    /**
+     * 小部件背景资源类
+     * 管理不同尺寸小部件的背景资源
+     */
     public static class WidgetBgResources {
+        /**
+         * 2x尺寸小部件背景资源数组
+         * 索引对应背景颜色常量
+         */
         private final static int [] BG_2X_RESOURCES = new int [] {
             R.drawable.widget_2x_yellow,
             R.drawable.widget_2x_blue,
@@ -137,10 +261,19 @@ public class ResourceParser {
             R.drawable.widget_2x_red,
         };
 
+        /**
+         * 获取2x尺寸小部件背景资源
+         * @param id 背景颜色ID
+         * @return 2x小部件背景资源ID
+         */
         public static int getWidget2xBgResource(int id) {
             return BG_2X_RESOURCES[id];
         }
 
+        /**
+         * 4x尺寸小部件背景资源数组
+         * 索引对应背景颜色常量
+         */
         private final static int [] BG_4X_RESOURCES = new int [] {
             R.drawable.widget_4x_yellow,
             R.drawable.widget_4x_blue,
@@ -149,19 +282,37 @@ public class ResourceParser {
             R.drawable.widget_4x_red
         };
 
+        /**
+         * 获取4x尺寸小部件背景资源
+         * @param id 背景颜色ID
+         * @return 4x小部件背景资源ID
+         */
         public static int getWidget4xBgResource(int id) {
             return BG_4X_RESOURCES[id];
         }
     }
 
+    /**
+     * 文本外观资源类
+     * 管理不同字体大小的文本样式资源
+     */
     public static class TextAppearanceResources {
+        /**
+         * 文本外观资源数组
+         * 索引对应字体大小常量
+         */
         private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
-            R.style.TextAppearanceNormal,
-            R.style.TextAppearanceMedium,
-            R.style.TextAppearanceLarge,
-            R.style.TextAppearanceSuper
+            R.style.TextAppearanceNormal,  // TEXT_SMALL
+            R.style.TextAppearanceMedium,   // TEXT_MEDIUM
+            R.style.TextAppearanceLarge,    // TEXT_LARGE
+            R.style.TextAppearanceSuper     // TEXT_SUPER
         };
 
+        /**
+         * 获取文本外观资源
+         * @param id 字体大小ID
+         * @return 文本外观资源ID
+         */
         public static int getTexAppearanceResource(int id) {
             /**
              * HACKME: Fix bug of store the resource id in shared preference.
@@ -174,6 +325,10 @@ public class ResourceParser {
             return TEXTAPPEARANCE_RESOURCES[id];
         }
 
+        /**
+         * 获取文本外观资源数量
+         * @return 文本外观资源数量
+         */
         public static int getResourcesSize() {
             return TEXTAPPEARANCE_RESOURCES.length;
         }
diff --git a/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java b/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
index 85723be..827b843 100644
--- a/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
@@ -40,21 +40,47 @@ import net.micode.notes.tool.DataUtils;
 import java.io.IOException;
 
 
+/**
+ * 闹钟提醒活动类
+ * 用于显示笔记提醒对话框并播放闹钟声音
+ */
 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 mPlayer;
 
+    /**
+     * 创建活动时调用的方法
+     * 设置窗口特性、处理意图数据、初始化播放器并显示提醒对话框
+     * @param savedInstanceState 保存的实例状态
+     */
     @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
@@ -64,8 +90,11 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
         Intent intent = getIntent();
 
         try {
+            // 从Intent中获取笔记ID
             mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
+            // 获取笔记摘要
             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;
@@ -74,7 +103,9 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
             return;
         }
 
+        // 初始化媒体播放器
         mPlayer = new MediaPlayer();
+        // 检查笔记是否可见，如果可见则显示对话框并播放声音
         if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
             showActionDialog();
             playAlarmSound();
@@ -83,17 +114,28 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
         }
     }
 
+    /**
+     * 检查屏幕是否开启
+     * @return 屏幕是否开启
+     */
     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);
 
+        // 设置音频流类型
         if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
             mPlayer.setAudioStreamType(silentModeStreams);
         } else {
@@ -102,57 +144,75 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
         try {
             mPlayer.setDataSource(this, url);
             mPlayer.prepare();
-            mPlayer.setLooping(true);
+            mPlayer.setLooping(true);  // 设置循环播放
             mPlayer.start();
         } catch (IllegalArgumentException e) {
-            // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (SecurityException e) {
-            // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (IllegalStateException e) {
-            // TODO Auto-generated catch block
             e.printStackTrace();
         } catch (IOException e) {
-            // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
 
+    /**
+     * 显示提醒对话框
+     * 对话框显示笔记摘要，并根据屏幕状态提供不同的按钮选项
+     */
     private void showActionDialog() {
         AlertDialog.Builder dialog = new AlertDialog.Builder(this);
         dialog.setTitle(R.string.app_name);
-        dialog.setMessage(mSnippet);
-        dialog.setPositiveButton(R.string.notealert_ok, this);
+        dialog.setMessage(mSnippet);  // 显示笔记摘要
+        dialog.setPositiveButton(R.string.notealert_ok, this);  // 确定按钮
         if (isScreenOn()) {
+            // 如果屏幕已开启，显示"进入"按钮
             dialog.setNegativeButton(R.string.notealert_enter, this);
         }
+        // 显示对话框并设置消失监听器
         dialog.show().setOnDismissListener(this);
     }
 
+    /**
+     * 处理对话框按钮点击事件
+     * @param dialog 对话框实例
+     * @param which 被点击的按钮ID
+     */
     public void onClick(DialogInterface dialog, int which) {
         switch (which) {
             case DialogInterface.BUTTON_NEGATIVE:
+                // 点击"进入"按钮，打开笔记编辑界面查看完整笔记
                 Intent intent = new Intent(this, NoteEditActivity.class);
                 intent.setAction(Intent.ACTION_VIEW);
                 intent.putExtra(Intent.EXTRA_UID, mNoteId);
                 startActivity(intent);
                 break;
             default:
+                // 点击"确定"按钮，不执行额外操作
                 break;
         }
     }
 
+    /**
+     * 处理对话框消失事件
+     * 停止闹钟声音并结束活动
+     * @param dialog 对话框实例
+     */
     public void onDismiss(DialogInterface dialog) {
-        stopAlarmSound();
-        finish();
+        stopAlarmSound();  // 停止闹钟声音
+        finish();          // 结束活动
     }
 
+    /**
+     * 停止闹钟声音
+     * 释放媒体播放器资源
+     */
     private void stopAlarmSound() {
         if (mPlayer != null) {
             mPlayer.stop();
-            mPlayer.release();
-            mPlayer = null;
+            mPlayer.release();  // 释放资源
+            mPlayer = null;      // 清空引用
         }
     }
 }
diff --git a/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java b/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
index f221202..c316842 100644
--- a/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
@@ -28,19 +28,38 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 
 
+/**
+ * 闹钟初始化广播接收器
+ * 用于系统启动或其他触发事件时重新设置所有笔记的闹钟提醒
+ */
 public class AlarmInitReceiver extends BroadcastReceiver {
 
+    /**
+     * 数据库查询投影
+     * 只查询需要的列：笔记ID和提醒日期
+     */
     private static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,
-        NoteColumns.ALERTED_DATE
+        NoteColumns.ID,         // 笔记ID
+        NoteColumns.ALERTED_DATE // 提醒日期
     };
 
-    private static final int COLUMN_ID                = 0;
-    private static final int COLUMN_ALERTED_DATE      = 1;
+    /**
+     * 查询结果列索引常量
+     */
+    private static final int COLUMN_ID                = 0;  // 笔记ID列索引
+    private static final int COLUMN_ALERTED_DATE      = 1;  // 提醒日期列索引
 
+    /**
+     * 接收广播时调用的方法
+     * 重新设置所有未来时间的笔记提醒闹钟
+     * @param context 上下文
+     * @param intent 接收到的意图
+     */
     @Override
     public void onReceive(Context context, Intent intent) {
         long currentDate = System.currentTimeMillis();
+        
+        // 查询数据库中所有设置了未来提醒日期的笔记
         Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                 PROJECTION,
                 NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
@@ -50,16 +69,23 @@ public class AlarmInitReceiver extends BroadcastReceiver {
         if (c != null) {
             if (c.moveToFirst()) {
                 do {
+                    // 获取提醒日期和笔记ID
                     long alertDate = c.getLong(COLUMN_ALERTED_DATE);
+                    
+                    // 创建闹钟接收器的意图
                     Intent sender = new Intent(context, AlarmReceiver.class);
                     sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
+                    
+                    // 创建PendingIntent用于触发闹钟
                     PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
+                    
+                    // 获取闹钟管理器并设置闹钟
                     AlarmManager alermManager = (AlarmManager) context
                             .getSystemService(Context.ALARM_SERVICE);
                     alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
                 } while (c.moveToNext());
             }
-            c.close();
+            c.close();  // 关闭游标
         }
     }
 }
diff --git a/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java b/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
index 54e503b..cb5edf7 100644
--- a/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
@@ -20,11 +20,24 @@ import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 
+/**
+ * 闹钟接收器类
+ * 用于接收闹钟触发事件并启动提醒活动
+ */
 public class AlarmReceiver extends BroadcastReceiver {
+    /**
+     * 接收闹钟触发广播时调用的方法
+     * 启动闹钟提醒活动显示笔记提醒
+     * @param context 上下文
+     * @param intent 接收到的意图，包含笔记ID
+     */
     @Override
     public void onReceive(Context context, Intent intent) {
+        // 将意图的目标类设置为闹钟提醒活动
         intent.setClass(context, AlarmAlertActivity.class);
+        // 添加新任务标志，允许从非活动上下文启动活动
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        // 启动闹钟提醒活动
         context.startActivity(intent);
     }
 }
diff --git a/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java b/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
index 496b0cd..9abc907 100644
--- a/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
+++ b/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
@@ -28,85 +28,135 @@ import android.view.View;
 import android.widget.FrameLayout;
 import android.widget.NumberPicker;
 
+/**
+ * 日期时间选择器组件
+ * 用于在笔记应用中设置提醒时间，支持24小时制和12小时制切换
+ * 提供日期、小时、分钟和AM/PM的选择功能
+ */
 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;
+    /** 24小时制小时选择器的最小值 */
     private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
+    /** 24小时制小时选择器的最大值 */
     private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
+    /** 12小时制小时选择器的最小值 */
     private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
+    /** 12小时制小时选择器的最大值 */
     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;
+    /** AM/PM选择器的最小值 */
     private static final int AMPM_SPINNER_MIN_VAL = 0;
+    /** AM/PM选择器的最大值 */
     private static final int AMPM_SPINNER_MAX_VAL = 1;
 
+    /** 日期选择器 */
     private final NumberPicker mDateSpinner;
+    /** 小时选择器 */
     private final NumberPicker mHourSpinner;
+    /** 分钟选择器 */
     private final NumberPicker mMinuteSpinner;
+    /** AM/PM选择器 */
     private final NumberPicker mAmPmSpinner;
+    /** 当前选择的日期 */
     private Calendar mDate;
 
+    /** 日期显示值数组 */
     private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
 
+    /** 是否为上午 */
     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();
+            
             if (!mIs24HourView) {
+                // 处理12小时制下的日期变更逻辑
                 if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
+                    // 从下午11点变为12点，日期加1天
                     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) {
+                    // 从上午12点变为11点，日期减1天
                     cal.setTimeInMillis(mDate.getTimeInMillis());
                     cal.add(Calendar.DAY_OF_YEAR, -1);
                     isDateChanged = true;
                 }
+                
+                // 处理12小时制下的AM/PM切换
                 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 {
+                // 处理24小时制下的日期变更逻辑
                 if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
+                    // 从23点变为0点，日期加1天
                     cal.setTimeInMillis(mDate.getTimeInMillis());
                     cal.add(Calendar.DAY_OF_YEAR, 1);
                     isDateChanged = true;
                 } else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
+                    // 从0点变为23点，日期减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));
@@ -115,21 +165,31 @@ public class DateTimePicker extends FrameLayout {
         }
     };
 
+    /** 分钟变化监听器 */
     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) {
+                // 分钟从59变为0，小时加1
                 offset += 1;
             } else if (oldVal == minValue && newVal == maxValue) {
+                // 分钟从0变为59，小时减1
                 offset -= 1;
             }
+            
             if (offset != 0) {
+                // 更新小时
                 mDate.add(Calendar.HOUR_OF_DAY, offset);
                 mHourSpinner.setValue(getCurrentHour());
+                // 更新日期显示
                 updateDateControl();
+                
+                // 更新AM/PM状态
                 int newHour = getCurrentHourOfDay();
                 if (newHour >= HOURS_IN_HALF_DAY) {
                     mIsAm = false;
@@ -139,38 +199,78 @@ public class DateTimePicker extends FrameLayout {
                     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) {
+            // 切换AM/PM状态
             mIsAm = !mIsAm;
+            
+            // 根据AM/PM状态调整小时
             if (mIsAm) {
+                // 从PM切换到AM，小时减12
                 mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
             } else {
+                // 从AM切换到PM，小时加12
                 mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
             }
+            
+            // 更新AM/PM选择器显示
             updateAmPmControl();
+            // 通知日期时间变化
             onDateTimeChanged();
         }
     };
 
+    /**
+     * 日期时间变化监听器接口
+     * 用于监听日期时间选择器的变化事件
+     */
     public interface OnDateTimeChangedListener {
+        /**
+         * 当日期时间发生变化时调用
+         * @param view 日期时间选择器实例
+         * @param year 年
+         * @param month 月
+         * @param dayOfMonth 日
+         * @param hourOfDay 时（24小时制）
+         * @param minute 分
+         */
         void onDateTimeChanged(DateTimePicker view, int year, int month,
                 int dayOfMonth, int hourOfDay, int minute);
     }
 
+    /**
+     * 创建一个日期时间选择器实例，使用当前时间和系统默认的时间格式
+     * @param context 上下文
+     */
     public DateTimePicker(Context context) {
         this(context, System.currentTimeMillis());
     }
 
+    /**
+     * 创建一个日期时间选择器实例，使用指定时间和系统默认的时间格式
+     * @param context 上下文
+     * @param date 指定的时间（毫秒）
+     */
     public DateTimePicker(Context context, long date) {
         this(context, date, DateFormat.is24HourFormat(context));
     }
 
+    /**
+     * 创建一个日期时间选择器实例，使用指定时间和时间格式
+     * @param context 上下文
+     * @param date 指定的时间（毫秒）
+     * @param is24HourView 是否使用24小时制
+     */
     public DateTimePicker(Context context, long date, boolean is24HourView) {
         super(context);
         mDate = Calendar.getInstance();
@@ -178,19 +278,24 @@ public class DateTimePicker extends FrameLayout {
         mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
         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);
+        mMinuteSpinner.setOnLongPressUpdateInterval(100); // 设置长按更新间隔
         mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
 
+        // 初始化AM/PM选择器
         String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
         mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
         mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
@@ -198,19 +303,21 @@ public class DateTimePicker extends FrameLayout {
         mAmPmSpinner.setDisplayedValues(stringsForAmPm);
         mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
 
-        // update controls to initial state
+        // 更新控件到初始状态
         updateDateControl();
         updateHourControl();
         updateAmPmControl();
 
+        // 设置时间格式（24小时制/12小时制）
         set24HourView(is24HourView);
 
-        // set to current time
+        // 设置初始时间
         setCurrentDate(date);
 
+        // 设置启用状态
         setEnabled(isEnabled());
 
-        // set the content descriptions
+        // 初始化完成
         mInitialising = false;
     }
 
@@ -348,14 +455,22 @@ public class DateTimePicker extends FrameLayout {
         return mDate.get(Calendar.HOUR_OF_DAY);
     }
 
+    /**
+     * 获取当前小时（根据时间格式返回适当的表示）
+     * @return 当前小时（24小时制返回0-23，12小时制返回1-12）
+     */
     private int getCurrentHour() {
         if (mIs24HourView){
+            // 24小时制直接返回小时
             return getCurrentHourOfDay();
         } else {
+            // 12小时制需要转换
             int hour = getCurrentHourOfDay();
             if (hour > HOURS_IN_HALF_DAY) {
+                // 下午时间，减去12
                 return hour - HOURS_IN_HALF_DAY;
             } else {
+                // 上午时间，0点转换为12点
                 return hour == 0 ? HOURS_IN_HALF_DAY : hour;
             }
         }
@@ -434,35 +549,54 @@ public class DateTimePicker extends FrameLayout {
         updateAmPmControl();
     }
 
+    /**
+     * 更新日期选择器的显示值
+     * 生成一周内的日期显示字符串
+     */
     private void updateDateControl() {
         Calendar cal = Calendar.getInstance();
         cal.setTimeInMillis(mDate.getTimeInMillis());
+        // 计算起始日期（当前日期减去3天）
         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);
+            // 格式化日期为"MM.dd EEEE"（月.日 星期几）
             mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
         }
+        
         mDateSpinner.setDisplayedValues(mDateDisplayValues);
-        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
+        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2); // 默认选择当前日期
         mDateSpinner.invalidate();
     }
 
+    /**
+     * 更新AM/PM选择器的显示
+     */
     private void updateAmPmControl() {
         if (mIs24HourView) {
+            // 24小时制隐藏AM/PM选择器
             mAmPmSpinner.setVisibility(View.GONE);
         } else {
+            // 12小时制设置AM/PM值并显示
             int index = mIsAm ? Calendar.AM : Calendar.PM;
             mAmPmSpinner.setValue(index);
             mAmPmSpinner.setVisibility(View.VISIBLE);
         }
     }
 
+    /**
+     * 更新小时选择器的范围
+     */
     private void updateHourControl() {
         if (mIs24HourView) {
+            // 24小时制范围：0-23
             mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
             mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
         } else {
+            // 12小时制范围：1-12
             mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
             mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
         }
@@ -476,6 +610,9 @@ public class DateTimePicker extends FrameLayout {
         mOnDateTimeChangedListener = callback;
     }
 
+    /**
+     * 通知日期时间变化
+     */
     private void onDateTimeChanged() {
         if (mOnDateTimeChangedListener != null) {
             mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
diff --git a/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java b/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
index 2c47ba4..b4a65f4 100644
--- a/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
+++ b/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
@@ -29,59 +29,114 @@ import android.content.DialogInterface.OnClickListener;
 import android.text.format.DateFormat;
 import android.text.format.DateUtils;
 
+/**
+ * 日期时间选择对话框
+ * 封装DateTimePicker组件，提供一个对话框界面让用户选择日期时间
+ */
 public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
 
+    /** 当前选择的日期 */
     private Calendar mDate = Calendar.getInstance();
+    /** 是否为24小时制 */
     private boolean mIs24HourView;
+    /** 日期时间设置监听器 */
     private OnDateTimeSetListener mOnDateTimeSetListener;
+    /** 日期时间选择器组件 */
     private DateTimePicker mDateTimePicker;
 
+    /**
+     * 日期时间设置监听器接口
+     * 用于监听用户选择日期时间后的确认事件
+     */
     public interface OnDateTimeSetListener {
+        /**
+         * 当用户确认选择日期时间时调用
+         * @param dialog 日期时间选择对话框实例
+         * @param date 选择的日期时间（毫秒）
+         */
         void OnDateTimeSet(AlertDialog dialog, long date);
     }
 
+    /**
+     * 创建一个日期时间选择对话框实例
+     * @param context 上下文
+     * @param date 初始日期时间（毫秒）
+     */
     public DateTimePickerDialog(Context context, long date) {
         super(context);
+        // 初始化日期时间选择器
         mDateTimePicker = new DateTimePicker(context);
         setView(mDateTimePicker);
+        
+        // 设置日期时间变化监听器
         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小时制/12小时制）
         set24HourView(DateFormat.is24HourFormat(this.getContext()));
+        
+        // 更新对话框标题
         updateTitle(mDate.getTimeInMillis());
     }
 
+    /**
+     * 设置是否使用24小时制
+     * @param is24HourView true表示使用24小时制，false表示使用12小时制
+     */
     public void set24HourView(boolean is24HourView) {
         mIs24HourView = 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_24HOUR;
+        // 格式化并设置标题
         setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
     }
 
+    /**
+     * 点击对话框按钮时调用
+     * @param arg0 对话框实例
+     * @param arg1 按钮索引
+     */
     public void onClick(DialogInterface arg0, int arg1) {
+        // 当点击确认按钮时，通知监听器日期时间已设置
         if (mOnDateTimeSetListener != null) {
             mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
         }
diff --git a/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java b/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
index 613dc74..5d5dfe9 100644
--- a/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
+++ b/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
@@ -27,17 +27,34 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
 
 import net.micode.notes.R;
 
+/**
+ * 下拉菜单组件
+ * 封装Android的PopupMenu功能，提供一个带有按钮和下拉菜单的组件
+ */
 public class DropdownMenu {
+    /** 下拉菜单的按钮 */
     private Button mButton;
+    /** 弹出菜单实例 */
     private PopupMenu mPopupMenu;
+    /** 菜单实例 */
     private Menu mMenu;
 
+    /**
+     * 创建一个下拉菜单实例
+     * @param context 上下文
+     * @param button 下拉菜单的按钮
+     * @param menuId 菜单资源ID
+     */
     public DropdownMenu(Context context, Button button, int menuId) {
         mButton = button;
+        // 设置按钮背景为下拉图标
         mButton.setBackgroundResource(R.drawable.dropdown_icon);
+        // 创建弹出菜单实例
         mPopupMenu = new PopupMenu(context, mButton);
         mMenu = mPopupMenu.getMenu();
+        // 填充菜单内容
         mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+        // 设置按钮点击事件，显示弹出菜单
         mButton.setOnClickListener(new OnClickListener() {
             public void onClick(View v) {
                 mPopupMenu.show();
@@ -45,16 +62,29 @@ public class DropdownMenu {
         });
     }
 
+    /**
+     * 设置菜单点击事件监听器
+     * @param listener 菜单项点击事件监听器
+     */
     public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
         if (mPopupMenu != null) {
             mPopupMenu.setOnMenuItemClickListener(listener);
         }
     }
 
+    /**
+     * 根据ID查找菜单项
+     * @param id 菜单项ID
+     * @return 菜单项实例，如果未找到返回null
+     */
     public MenuItem findItem(int id) {
         return mMenu.findItem(id);
     }
 
+    /**
+     * 设置下拉菜单按钮的标题
+     * @param title 标题文本
+     */
     public void setTitle(CharSequence title) {
         mButton.setText(title);
     }
diff --git a/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java b/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
index 96b77da..9a4e9f6 100644
--- a/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
+++ b/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
@@ -29,49 +29,94 @@ 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
+        NoteColumns.ID,      // 文件夹ID
+        NoteColumns.SNIPPET  // 文件夹名称
     };
 
+    /** 文件夹ID列索引 */
     public static final int ID_COLUMN   = 0;
+    /** 文件夹名称列索引 */
     public static final int NAME_COLUMN = 1;
 
+    /**
+     * 创建一个文件夹列表适配器实例
+     * @param context 上下文
+     * @param c 包含文件夹数据的Cursor
+     */
     public FoldersListAdapter(Context context, Cursor c) {
         super(context, c);
-        // TODO Auto-generated constructor stub
     }
 
+    /**
+     * 创建一个新的文件夹列表项视图
+     * @param context 上下文
+     * @param cursor 包含文件夹数据的Cursor
+     * @param parent 父视图组
+     * @return 新创建的文件夹列表项视图
+     */
     @Override
     public View newView(Context context, Cursor cursor, ViewGroup parent) {
         return new FolderListItem(context);
     }
 
+    /**
+     * 将文件夹数据绑定到列表项视图
+     * @param view 列表项视图
+     * @param context 上下文
+     * @param cursor 包含文件夹数据的Cursor
+     */
     @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);
         }
     }
 
+    /**
+     * 获取指定位置的文件夹名称
+     * @param context 上下文
+     * @param position 位置索引
+     * @return 文件夹名称
+     */
     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);
     }
 
+    /**
+     * 文件夹列表项视图
+     */
     private class FolderListItem extends LinearLayout {
+        /** 文件夹名称文本视图 */
         private TextView mName;
 
+        /**
+         * 创建一个文件夹列表项视图
+         * @param context 上下文
+         */
         public FolderListItem(Context context) {
             super(context);
+            // 填充布局
             inflate(context, R.layout.folder_list_item, this);
             mName = (TextView) findViewById(R.id.tv_folder_name);
         }
 
+        /**
+         * 绑定文件夹名称到视图
+         * @param name 文件夹名称
+         */
         public void bind(String name) {
             mName.setText(name);
         }
diff --git a/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java b/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
index 96a9ff8..8de37b8 100644
--- a/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
@@ -72,18 +72,28 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 
+/**
+ * 笔记编辑活动类
+ * 负责处理笔记的创建、编辑和预览功能
+ * 实现了笔记设置变化监听器和文本视图变化监听器接口
+ */
 public class NoteEditActivity extends Activity implements OnClickListener,
         NoteSettingChangedListener, OnTextViewChangeListener {
+    /**
+     * 头部视图持有者类
+     * 用于缓存头部视图的控件引用，提高性能
+     */
     private class HeadViewHolder {
-        public TextView tvModified;
-
-        public ImageView ivAlertIcon;
-
-        public TextView tvAlertDate;
-
-        public ImageView ibSetBgColor;
+        public TextView tvModified;       // 最后修改时间文本视图
+        public ImageView ivAlertIcon;     // 提醒图标
+        public TextView tvAlertDate;      // 提醒日期文本视图
+        public ImageView ibSetBgColor;    // 设置背景颜色按钮
     }
 
+    /**
+     * 背景选择器按钮映射
+     * 用于将背景选择按钮ID映射到对应的背景颜色常量
+     */
     private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
     static {
         sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@@ -93,6 +103,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
     }
 
+    /**
+     * 背景选择器选中状态映射
+     * 用于将背景颜色常量映射到对应的选中状态图标ID
+     */
     private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
     static {
         sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@@ -102,6 +116,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
     }
 
+    /**
+     * 字体大小按钮映射
+     * 用于将字体大小选择按钮ID映射到对应的字体大小常量
+     */
     private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
     static {
         sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
@@ -110,6 +128,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
     }
 
+    /**
+     * 字体选择器选中状态映射
+     * 用于将字体大小常量映射到对应的选中状态图标ID
+     */
     private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
     static {
         sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@@ -118,52 +140,47 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
     }
 
-    private static final String TAG = "NoteEditActivity";
-
-    private HeadViewHolder mNoteHeaderHolder;
-
-    private View mHeadViewPanel;
-
-    private View mNoteBgColorSelector;
-
-    private View mFontSizeSelector;
+    private static final String TAG = "NoteEditActivity";  // 日志标签
 
-    private EditText mNoteEditor;
+    private HeadViewHolder mNoteHeaderHolder;        // 头部视图持有者
+    private View mHeadViewPanel;                    // 头部视图面板
+    private View mNoteBgColorSelector;              // 背景颜色选择器
+    private View mFontSizeSelector;                 // 字体大小选择器
+    private EditText mNoteEditor;                   // 笔记编辑器
+    private View mNoteEditorPanel;                  // 笔记编辑器面板
+    private WorkingNote mWorkingNote;               // 工作笔记对象
+    private SharedPreferences mSharedPrefs;         // 共享偏好设置
+    private int mFontSizeId;                        // 字体大小ID
 
-    private View mNoteEditorPanel;
+    private static final String PREFERENCE_FONT_SIZE = "pref_font_size";  // 字体大小偏好设置键
+    private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;  // 快捷图标标题最大长度
 
-    private WorkingNote mWorkingNote;
+    public static final String TAG_CHECKED = String.valueOf('\u221A');  // 已勾选标记
+    public static final String TAG_UNCHECKED = String.valueOf('\u25A1');  // 未勾选标记
 
-    private SharedPreferences mSharedPrefs;
-    private int mFontSizeId;
-
-    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;
+    private LinearLayout mEditTextList;             // 编辑文本列表（用于清单模式）
+    private String mUserQuery;                      // 用户查询字符串
+    private Pattern mPattern;                       // 正则表达式模式（用于高亮查询结果）
 
+    /**
+     * 创建活动时调用
+     * @param savedInstanceState 保存的实例状态
+     */
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        this.setContentView(R.layout.note_edit);
+        this.setContentView(R.layout.note_edit);  // 设置布局
 
+        // 如果没有保存的状态且无法初始化活动状态，则结束活动
         if (savedInstanceState == null && !initActivityState(getIntent())) {
             finish();
             return;
         }
-        initResources();
+        initResources();  // 初始化资源
     }
 
     /**
-     * Current activity may be killed when the memory is low. Once it is killed, for another time
-     * user load this activity, we should restore the former state
+     * 当前活动在内存不足时可能被杀死。一旦被杀死，当用户再次加载此活动时，我们应该恢复以前的状态
      */
     @Override
     protected void onRestoreInstanceState(Bundle savedInstanceState) {
@@ -179,6 +196,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    /**
+     * 初始化活动状态
+     * 根据传入的意图设置工作笔记的状态
+     * @param intent 传入的意图
+     * @return 是否初始化成功
+     */
     private boolean initActivityState(Intent intent) {
         /**
          * If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
@@ -262,27 +285,44 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return true;
     }
 
+    /**
+     * 活动恢复时调用
+     */
     @Override
     protected void onResume() {
         super.onResume();
-        initNoteScreen();
+        initNoteScreen();  // 初始化笔记屏幕
     }
 
+    /**
+     * 初始化笔记屏幕
+     * 设置笔记编辑器的文本外观、内容和选择模式
+     */
     private void initNoteScreen() {
+        // 设置笔记编辑器的文本外观
         mNoteEditor.setTextAppearance(this, TextAppearanceResources
                 .getTexAppearanceResource(mFontSizeId));
+        
+        // 根据笔记模式设置显示方式
         if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
-            switchToListMode(mWorkingNote.getContent());
+            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
@@ -292,9 +332,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
          * TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker
          * is not ready
          */
-        showAlertHeader();
+        showAlertHeader();  // 显示提醒头部
     }
 
+    /**
+     * 显示提醒头部
+     * 根据笔记的提醒设置显示或隐藏提醒信息
+     */
     private void showAlertHeader() {
         if (mWorkingNote.hasClockAlert()) {
             long time = System.currentTimeMillis();
@@ -318,6 +362,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         initActivityState(intent);
     }
 
+    /**
+     * 保存活动状态
+     * @param outState 保存状态的Bundle
+     */
     @Override
     protected void onSaveInstanceState(Bundle outState) {
         super.onSaveInstanceState(outState);
@@ -333,6 +381,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
     }
 
+    /**
+     * 分发触摸事件
+     * 处理背景颜色选择器和字体大小选择器的点击外部关闭逻辑
+     * @param ev 触摸事件
+     * @return 是否消费了事件
+     */
     @Override
     public boolean dispatchTouchEvent(MotionEvent ev) {
         if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
@@ -349,6 +403,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return super.dispatchTouchEvent(ev);
     }
 
+    /**
+     * 检查触摸事件是否在视图范围内
+     * @param view 视图对象
+     * @param ev 触摸事件
+     * @return 是否在范围内
+     */
     private boolean inRangeOfView(View view, MotionEvent ev) {
         int []location = new int[2];
         view.getLocationOnScreen(location);
@@ -363,6 +423,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return true;
     }
 
+    /**
+     * 初始化资源
+     * 初始化所有UI控件和资源引用
+     */
     private void initResources() {
         mHeadViewPanel = findViewById(R.id.note_title);
         mNoteHeaderHolder = new HeadViewHolder();
@@ -374,18 +438,25 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         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);
         mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
+        
         /**
          * HACKME: Fix bug of store the resource id in shared preference.
          * The id may larger than the length of resources, in this case,
@@ -394,9 +465,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
             mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
         }
+        
         mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
     }
 
+    /**
+     * 活动暂停时调用
+     * 保存笔记并清除设置状态
+     */
     @Override
     protected void onPause() {
         super.onPause();
@@ -406,8 +482,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         clearSettingState();
     }
 
+    /**
+     * 更新小部件
+     * 更新与当前笔记关联的小部件内容
+     */
     private void updateWidget() {
         Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
+        
+        // 根据小部件类型设置对应的小部件提供器
         if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
             intent.setClass(this, NoteWidgetProvider_2x.class);
         } else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
@@ -421,26 +503,36 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             mWorkingNote.getWidgetId()
         });
 
-        sendBroadcast(intent);
+        sendBroadcast(intent);  // 发送广播更新小部件
         setResult(RESULT_OK, intent);
     }
 
+    /**
+     * 点击事件处理
+     * 处理各种UI控件的点击事件
+     * @param v 被点击的视图
+     */
     public void onClick(View v) {
         int id = v.getId();
         if (id == R.id.btn_set_bg_color) {
+            // 显示背景颜色选择器
             mNoteBgColorSelector.setVisibility(View.VISIBLE);
             findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
-                    -                    View.VISIBLE);
+                    View.VISIBLE);
         } else if (sBgSelectorBtnsMap.containsKey(id)) {
+            // 处理背景颜色选择
             findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                     View.GONE);
             mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
             mNoteBgColorSelector.setVisibility(View.GONE);
         } else if (sFontSizeBtnsMap.containsKey(id)) {
+            // 处理字体大小选择
             findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
             mFontSizeId = sFontSizeBtnsMap.get(id);
             mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
             findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
+            
+            // 根据当前模式更新字体大小
             if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
                 getWorkingText();
                 switchToListMode(mWorkingNote.getContent());
@@ -452,6 +544,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    /**
+     * 按下返回键时调用
+     */
     @Override
     public void onBackPressed() {
         if(clearSettingState()) {
@@ -462,6 +557,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         super.onBackPressed();
     }
 
+    /**
+     * 清除设置状态
+     * 隐藏所有设置面板
+     * @return 是否有设置面板被隐藏
+     */
     private boolean clearSettingState() {
         if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
             mNoteBgColorSelector.setVisibility(View.GONE);
@@ -473,6 +573,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return false;
     }
 
+    /**
+     * 背景颜色改变时调用
+     * 实现NoteSettingChangedListener接口
+     */
     public void onBackgroundColorChanged() {
         findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                 View.VISIBLE);
@@ -480,6 +584,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
     }
 
+    /**
+     * 准备菜单时调用
+     * @param menu 菜单对象
+     * @return 是否准备成功
+     */
     @Override
     public boolean onPrepareOptionsMenu(Menu menu) {
         if (isFinishing()) {
@@ -505,13 +614,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return true;
     }
 
+    /**
+     * 菜单项选择处理
+     * 处理各种菜单按钮的点击事件
+     * @param item 选择的菜单项
+     * @return 是否处理了该事件
+     */
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
             case R.id.menu_new_note:
-                createNewNote();
+                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);
@@ -519,7 +635,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                 builder.setPositiveButton(android.R.string.ok,
                         new DialogInterface.OnClickListener() {
                             public void onClick(DialogInterface dialog, int which) {
-                                deleteCurrentNote();
+                                deleteCurrentNote();  // 删除当前笔记
                                 finish();
                             }
                         });
@@ -527,25 +643,27 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                 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());
+                getWorkingText();  // 获取当前工作文本
+                sendTo(this, mWorkingNote.getContent());  // 分享笔记内容
                 break;
             case R.id.menu_send_to_desktop:
-                sendToDesktop();
+                sendToDesktop();  // 发送到桌面
                 break;
             case R.id.menu_alert:
-                setReminder();
+                setReminder();  // 设置提醒
                 break;
             case R.id.menu_delete_remind:
-                mWorkingNote.setAlertDate(0, false);
+                mWorkingNote.setAlertDate(0, false);  // 删除提醒
                 break;
             default:
                 break;
@@ -553,6 +671,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return true;
     }
 
+    /**
+     * 设置提醒
+     * 显示日期时间选择器，设置笔记的提醒时间
+     */
     private void setReminder() {
         DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
         d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
@@ -564,8 +686,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
     }
 
     /**
-     * Share note to apps that support {@link Intent#ACTION_SEND} action
-     * and {@text/plain} type
+     * 分享笔记
+     * 分享笔记内容到支持{@link Intent#ACTION_SEND}动作和{@text/plain}类型的应用
+     * @param context 上下文对象
+     * @param info 要分享的内容
      */
     private void sendTo(Context context, String info) {
         Intent intent = new Intent(Intent.ACTION_SEND);
@@ -574,11 +698,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         context.startActivity(intent);
     }
 
+    /**
+     * 创建新笔记
+     * 保存当前笔记并创建一个新的笔记
+     */
     private void createNewNote() {
-        // Firstly, save current editing notes
+        // 首先保存当前编辑的笔记
         saveNote();
 
-        // For safety, start a new NoteEditActivity
+        // 为了安全起见，启动一个新的NoteEditActivity
         finish();
         Intent intent = new Intent(this, NoteEditActivity.class);
         intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
@@ -586,6 +714,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         startActivity(intent);
     }
 
+    /**
+     * 删除当前笔记
+     * 根据同步模式决定是直接删除还是移动到回收站
+     */
     private void deleteCurrentNote() {
         if (mWorkingNote.existInDatabase()) {
             HashSet<Long> ids = new HashSet<Long>();
@@ -596,10 +728,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                 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");
                 }
@@ -608,10 +742,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         mWorkingNote.markDeleted(true);
     }
 
+    /**
+     * 检查是否为同步模式
+     * @return 是否为同步模式
+     */
     private boolean isSyncMode() {
         return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
     }
 
+    /**
+     * 提醒时间改变时调用
+     * 实现NoteSettingChangedListener接口
+     * @param date 提醒时间
+     * @param set 是否设置提醒
+     */
     public void onClockAlertChanged(long date, boolean set) {
         /**
          * User could set clock to an unsaved note, so before setting the
@@ -642,10 +786,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    /**
+     * 小部件改变时调用
+     * 实现NoteSettingChangedListener接口
+     */
     public void onWidgetChanged() {
         updateWidget();
     }
 
+    /**
+     * 编辑文本删除时调用
+     * 实现OnTextViewChangeListener接口
+     * @param index 删除的索引
+     * @param text 删除的文本
+     */
     public void onEditTextDelete(int index, String text) {
         int childCount = mEditTextList.getChildCount();
         if (childCount == 1) {
@@ -672,6 +826,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         edit.setSelection(length);
     }
 
+    /**
+     * 编辑文本回车时调用
+     * 实现OnTextViewChangeListener接口
+     * @param index 当前索引
+     * @param text 文本内容
+     */
     public void onEditTextEnter(int index, String text) {
         /**
          * Should not happen, check for debug
@@ -691,30 +851,43 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    /**
+     * 切换到清单模式
+     * 将普通文本模式转换为清单模式
+     * @param text 要转换的文本内容
+     */
     private void switchToListMode(String text) {
-        mEditTextList.removeAllViews();
-        String[] items = text.split("\n");
+        mEditTextList.removeAllViews();  // 清空编辑文本列表
+        String[] items = text.split("\n");  // 按行分割文本
         int index = 0;
         for (String item : items) {
             if(!TextUtils.isEmpty(item)) {
-                mEditTextList.addView(getListItem(item, index));
+                mEditTextList.addView(getListItem(item, index));  // 添加列表项
                 index++;
             }
         }
-        mEditTextList.addView(getListItem("", index));
-        mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
+        mEditTextList.addView(getListItem("", index));  // 添加最后一个空列表项
+        mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();  // 设置焦点
 
-        mNoteEditor.setVisibility(View.GONE);
-        mEditTextList.setVisibility(View.VISIBLE);
+        mNoteEditor.setVisibility(View.GONE);  // 隐藏普通编辑器
+        mEditTextList.setVisibility(View.VISIBLE);  // 显示清单编辑器
     }
 
+    /**
+     * 获取高亮查询结果
+     * 对文本中的查询关键词进行高亮处理
+     * @param fullText 完整文本
+     * @param userQuery 用户查询字符串
+     * @return 带有高亮效果的文本
+     */
     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);
+            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(),
@@ -725,10 +898,19 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         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) {
@@ -740,6 +922,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
             }
         });
 
+        // 处理已勾选和未勾选的标记
         if (item.startsWith(TAG_CHECKED)) {
             cb.setChecked(true);
             edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
@@ -756,6 +939,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return view;
     }
 
+    /**
+     * 文本内容改变时调用
+     * 实现OnTextViewChangeListener接口
+     * @param index 当前索引
+     * @param hasText 是否有文本内容
+     */
     public void onTextChange(int index, boolean hasText) {
         if (index >= mEditTextList.getChildCount()) {
             Log.e(TAG, "Wrong index, should not happen");
@@ -768,6 +957,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    /**
+     * 清单模式改变时调用
+     * 实现NoteSettingChangedListener接口
+     * @param oldMode 旧模式
+     * @param newMode 新模式
+     */
     public void onCheckListModeChanged(int oldMode, int newMode) {
         if (newMode == TextNote.MODE_CHECK_LIST) {
             switchToListMode(mNoteEditor.getText().toString());
@@ -782,6 +977,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    /**
+     * 获取当前工作文本
+     * 根据笔记模式获取当前编辑的文本内容
+     * @return 是否有已勾选的项目
+     */
     private boolean getWorkingText() {
         boolean hasChecked = false;
         if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
@@ -805,9 +1005,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return hasChecked;
     }
 
+    /**
+     * 保存笔记
+     * @return 是否保存成功
+     */
     private boolean saveNote() {
-        getWorkingText();
-        boolean saved = mWorkingNote.saveNote();
+        getWorkingText();  // 获取当前工作文本
+        boolean saved = mWorkingNote.saveNote();  // 保存笔记到数据库
         if (saved) {
             /**
              * There are two modes from List view to edit view, open one note,
@@ -821,6 +1025,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         return saved;
     }
 
+    /**
+     * 发送到桌面
+     * 在桌面上创建当前笔记的快捷方式
+     */
     private void sendToDesktop() {
         /**
          * Before send message to home, we should make sure that current
@@ -856,6 +1064,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    /**
+     * 创建快捷图标标题
+     * 处理快捷图标标题，移除标记并限制长度
+     * @param content 笔记内容
+     * @return 快捷图标标题
+     */
     private String makeShortcutIconTitle(String content) {
         content = content.replace(TAG_CHECKED, "");
         content = content.replace(TAG_UNCHECKED, "");
@@ -863,10 +1077,19 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                 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();
     }
diff --git a/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java b/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
index 2afe2a8..d149265 100644
--- a/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
@@ -37,20 +37,31 @@ import net.micode.notes.R;
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * 笔记编辑文本组件
+ * 自定义的EditText组件，用于笔记编辑，支持链接检测和特殊的键盘事件处理
+ */
 public class NoteEditText extends EditText {
+    /** 日志标签 */
     private static final String TAG = "NoteEditText";
+    /** 当前文本框的索引 */
     private int mIndex;
+    /** 删除前的选择起始位置 */
     private int mSelectionStartBeforeDelete;
 
+    /** 电话链接协议 */
     private static final String SCHEME_TEL = "tel:" ;
+    /** HTTP链接协议 */
     private static final String SCHEME_HTTP = "http:" ;
+    /** 电子邮件链接协议 */
     private static final String SCHEME_EMAIL = "mailto:" ;
 
+    /** 链接协议与对应的操作资源ID映射 */
     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);
+        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); // 电子邮件链接操作文本
     }
 
     /**
@@ -77,33 +88,60 @@ public class NoteEditText extends EditText {
 
     private OnTextViewChangeListener mOnTextViewChangeListener;
 
+    /**
+     * 创建一个笔记编辑文本组件实例
+     * @param context 上下文
+     */
     public NoteEditText(Context context) {
         super(context, null);
         mIndex = 0;
     }
 
+    /**
+     * 设置当前文本框的索引
+     * @param index 索引值
+     */
     public void setIndex(int index) {
         mIndex = index;
     }
 
+    /**
+     * 设置文本视图变化监听器
+     * @param listener 监听器实例
+     */
     public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
         mOnTextViewChangeListener = listener;
     }
 
+    /**
+     * 创建一个笔记编辑文本组件实例
+     * @param context 上下文
+     * @param attrs 属性集
+     */
     public NoteEditText(Context context, AttributeSet attrs) {
         super(context, attrs, android.R.attr.editTextStyle);
     }
 
+    /**
+     * 创建一个笔记编辑文本组件实例
+     * @param context 上下文
+     * @param attrs 属性集
+     * @param defStyle 默认样式
+     */
     public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
-        // TODO Auto-generated constructor stub
     }
 
+    /**
+     * 处理触摸事件
+     * @param event 触摸事件
+     * @return 是否消费了事件
+     */
     @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();
@@ -114,6 +152,7 @@ public class NoteEditText extends EditText {
                 Layout layout = getLayout();
                 int line = layout.getLineForVertical(y);
                 int off = layout.getOffsetForHorizontal(line, x);
+                // 设置选择位置
                 Selection.setSelection(getText(), off);
                 break;
         }
@@ -121,15 +160,23 @@ public class NoteEditText extends EditText {
         return super.onTouchEvent(event);
     }
 
+    /**
+     * 处理按键按下事件
+     * @param keyCode 按键码
+     * @param event 按键事件
+     * @return 是否消费了事件
+     */
     @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:
@@ -138,11 +185,18 @@ public class NoteEditText extends EditText {
         return super.onKeyDown(keyCode, event);
     }
 
+    /**
+     * 处理按键抬起事件
+     * @param keyCode 按键码
+     * @param event 按键事件
+     * @return 是否消费了事件
+     */
     @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;
@@ -153,6 +207,7 @@ public class NoteEditText extends EditText {
                 break;
             case KeyEvent.KEYCODE_ENTER:
                 if (mOnTextViewChangeListener != null) {
+                    // 处理回车键，将光标后的文本移到新的文本框
                     int selectionStart = getSelectionStart();
                     String text = getText().subSequence(selectionStart, length()).toString();
                     setText(getText().subSequence(0, selectionStart));
@@ -167,9 +222,16 @@ public class NoteEditText extends EditText {
         return super.onKeyUp(keyCode, event);
     }
 
+    /**
+     * 处理焦点变化事件
+     * @param focused 是否获得焦点
+     * @param direction 焦点变化方向
+     * @param previouslyFocusedRect 之前焦点所在的矩形
+     */
     @Override
     protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
         if (mOnTextViewChangeListener != null) {
+            // 当失去焦点且文本为空时，通知监听器文本已清空
             if (!focused && TextUtils.isEmpty(getText())) {
                 mOnTextViewChangeListener.onTextChange(mIndex, false);
             } else {
@@ -179,6 +241,10 @@ public class NoteEditText extends EditText {
         super.onFocusChanged(focused, direction, previouslyFocusedRect);
     }
 
+    /**
+     * 创建上下文菜单
+     * @param menu 上下文菜单
+     */
     @Override
     protected void onCreateContextMenu(ContextMenu menu) {
         if (getText() instanceof Spanned) {
@@ -188,8 +254,10 @@ public class NoteEditText extends EditText {
             int min = Math.min(selStart, selEnd);
             int max = Math.max(selStart, selEnd);
 
+            // 获取选中文本中的URL链接
             final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
             if (urls.length == 1) {
+                // 根据链接协议获取对应的操作文本
                 int defaultResId = 0;
                 for(String schema: sSchemaActionResMap.keySet()) {
                     if(urls[0].getURL().indexOf(schema) >= 0) {
@@ -199,13 +267,14 @@ public class NoteEditText extends EditText {
                 }
 
                 if (defaultResId == 0) {
-                    defaultResId = R.string.note_link_other;
+                    defaultResId = R.string.note_link_other; // 默认操作文本
                 }
 
+                // 添加菜单项并设置点击事件
                 menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
                         new OnMenuItemClickListener() {
                             public boolean onMenuItemClick(MenuItem item) {
-                                // goto a new intent
+                                // 处理链接点击事件
                                 urls[0].onClick(NoteEditText.this);
                                 return true;
                             }
diff --git a/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java b/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
index 0f5a878..7475760 100644
--- a/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
@@ -26,56 +26,97 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.tool.DataUtils;
 
 
+/**
+ * 笔记列表项数据类
+ * 用于存储和管理笔记列表中每个项的数据
+ */
 public class NoteItemData {
+    /** 数据库查询投影数组 */
     static final String [] PROJECTION = 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.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,        // 小部件ID
+        NoteColumns.WIDGET_TYPE,      // 小部件类型
     };
 
+    /** 笔记ID列索引 */
     private static final int ID_COLUMN                    = 0;
+    /** 提醒日期列索引 */
     private static final int ALERTED_DATE_COLUMN          = 1;
+    /** 背景颜色ID列索引 */
     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;
+    /** 父文件夹ID列索引 */
     private static final int PARENT_ID_COLUMN             = 7;
+    /** 笔记摘要列索引 */
     private static final int SNIPPET_COLUMN               = 8;
+    /** 笔记类型列索引 */
     private static final int TYPE_COLUMN                  = 9;
+    /** 小部件ID列索引 */
     private static final int WIDGET_ID_COLUMN             = 10;
+    /** 小部件类型列索引 */
     private static final int WIDGET_TYPE_COLUMN           = 11;
 
+    /** 笔记ID */
     private long mId;
+    /** 提醒日期 */
     private long mAlertDate;
+    /** 背景颜色ID */
     private int mBgColorId;
+    /** 创建日期 */
     private long mCreatedDate;
+    /** 是否有附件 */
     private boolean mHasAttachment;
+    /** 修改日期 */
     private long mModifiedDate;
+    /** 笔记数量 */
     private int mNotesCount;
+    /** 父文件夹ID */
     private long mParentId;
+    /** 笔记摘要 */
     private String mSnippet;
+    /** 笔记类型 */
     private int mType;
+    /** 小部件ID */
     private int mWidgetId;
+    /** 小部件类型 */
     private int mWidgetType;
+    /** 联系人姓名（用于通话记录） */
     private String mName;
+    /** 电话号码（用于通话记录） */
     private String mPhoneNumber;
 
+    /** 是否为最后一项 */
     private boolean mIsLastItem;
+    /** 是否为第一项 */
     private boolean mIsFirstItem;
+    /** 是否只有一项 */
     private boolean mIsOnlyOneItem;
+    /** 是否是文件夹后的唯一笔记 */
     private boolean mIsOneNoteFollowingFolder;
+    /** 是否是文件夹后的多个笔记 */
     private boolean mIsMultiNotesFollowingFolder;
 
+    /**
+     * 创建一个笔记列表项数据实例
+     * @param context 上下文
+     * @param cursor 包含笔记数据的Cursor
+     */
     public NoteItemData(Context context, Cursor cursor) {
         mId = cursor.getLong(ID_COLUMN);
         mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
@@ -86,6 +127,7 @@ public class NoteItemData {
         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);
@@ -93,6 +135,7 @@ public class NoteItemData {
         mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
 
         mPhoneNumber = "";
+        // 如果是通话记录文件夹中的笔记，获取电话号码和联系人姓名
         if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
             mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
             if (!TextUtils.isEmpty(mPhoneNumber)) {
@@ -106,9 +149,14 @@ public class NoteItemData {
         if (mName == null) {
             mName = "";
         }
+        // 检查笔记在列表中的位置
         checkPostion(cursor);
     }
 
+    /**
+     * 检查笔记在列表中的位置
+     * @param cursor 包含笔记数据的Cursor
+     */
     private void checkPostion(Cursor cursor) {
         mIsLastItem = cursor.isLast() ? true : false;
         mIsFirstItem = cursor.isFirst() ? true : false;
@@ -116,17 +164,20 @@ public class NoteItemData {
         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;
                     }
                 }
+                // 恢复Cursor位置
                 if (!cursor.moveToNext()) {
                     throw new IllegalStateException("cursor move to previous but can't move back");
                 }
@@ -134,90 +185,179 @@ public class NoteItemData {
         }
     }
 
+    /**
+     * 是否是文件夹后的唯一笔记
+     * @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
+     * @return 文件夹ID
+     */
     public long getFolderId () {
         return mParentId;
     }
 
+    /**
+     * 获取笔记类型
+     * @return 笔记类型
+     */
     public int getType() {
         return mType;
     }
 
+    /**
+     * 获取小部件类型
+     * @return 小部件类型
+     */
     public int getWidgetType() {
         return mWidgetType;
     }
 
+    /**
+     * 获取小部件ID
+     * @return 小部件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));
     }
 
+    /**
+     * 从Cursor中获取笔记类型
+     * @param cursor 包含笔记数据的Cursor
+     * @return 笔记类型
+     */
     public static int getNoteType(Cursor cursor) {
         return cursor.getInt(TYPE_COLUMN);
     }
diff --git a/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java b/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
index e843aec..e9e3893 100644
--- a/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
@@ -78,85 +78,89 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.HashSet;
 
+/**
+ * 笔记列表活动类 - 负责显示和管理笔记列表
+ * 提供笔记的创建、编辑、删除、移动等功能
+ * 支持文件夹管理和多选操作模式
+ */
 public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
-    private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
-
-    private static final int FOLDER_LIST_QUERY_TOKEN      = 1;
-
-    private static final int MENU_FOLDER_DELETE = 0;
+    // 异步查询处理的标记常量
+    private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0; // 查询笔记列表的标记
+    private static final int FOLDER_LIST_QUERY_TOKEN      = 1; // 查询文件夹列表的标记
 
-    private static final int MENU_FOLDER_VIEW = 1;
-
-    private static final int MENU_FOLDER_CHANGE_NAME = 2;
+    // 文件夹上下文菜单的菜单项ID
+    private static final int MENU_FOLDER_DELETE = 0;         // 删除文件夹
+    private static final int MENU_FOLDER_VIEW = 1;           // 查看文件夹
+    private static final int MENU_FOLDER_CHANGE_NAME = 2;    // 修改文件夹名称
 
+    // 用于存储应用介绍是否已添加的偏好设置键
     private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
 
+    // 列表编辑状态枚举
     private enum ListEditState {
-        NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
+        NOTE_LIST,            // 笔记列表状态
+        SUB_FOLDER,           // 子文件夹状态
+        CALL_RECORD_FOLDER    // 通话记录文件夹状态
     };
 
-    private ListEditState mState;
-
-    private BackgroundQueryHandler mBackgroundQueryHandler;
-
-    private NotesListAdapter mNotesListAdapter;
-
-    private ListView mNotesListView;
-
-    private Button mAddNewNote;
-
-    private boolean mDispatch;
-
-    private int mOriginY;
-
-    private int mDispatchY;
-
-    private TextView mTitleBar;
-
-    private long mCurrentFolderId;
-
-    private ContentResolver mContentResolver;
-
-    private ModeCallback mModeCallBack;
-
-    private static final String TAG = "NotesListActivity";
-
-    public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
-
-    private NoteItemData mFocusNoteDataItem;
-
-    private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
-
+    // 成员变量
+    private ListEditState mState;                           // 当前列表编辑状态
+    private BackgroundQueryHandler mBackgroundQueryHandler; // 异步查询处理器
+    private NotesListAdapter mNotesListAdapter;             // 笔记列表适配器
+    private ListView mNotesListView;                        // 笔记列表视图
+    private Button mAddNewNote;                             // 新建笔记按钮
+    private boolean mDispatch;                              // 是否分发触摸事件给列表视图
+    private int mOriginY;                                   // 原始触摸Y坐标
+    private int mDispatchY;                                 // 分发触摸Y坐标
+    private TextView mTitleBar;                             // 标题栏
+    private long mCurrentFolderId;                          // 当前文件夹ID
+    private ContentResolver mContentResolver;               // 内容解析器
+    private ModeCallback mModeCallBack;                     // 多选模式回调
+
+    private static final String TAG = "NotesListActivity";  // 日志标签
+    public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;// 笔记列表滚动速率
+
+    private NoteItemData mFocusNoteDataItem;                // 当前焦点的笔记数据项
+
+    // 查询条件常量
+    private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?"; // 普通文件夹查询条件
     private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"
             + Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
             + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
-            + NoteColumns.NOTES_COUNT + ">0)";
+            + NoteColumns.NOTES_COUNT + ">0)"; // 根文件夹查询条件（显示非系统文件夹和非空通话记录文件夹）
 
-    private final static int REQUEST_CODE_OPEN_NODE = 102;
-    private final static int REQUEST_CODE_NEW_NODE  = 103;
+    // 请求码常量
+    private final static int REQUEST_CODE_OPEN_NODE = 102; // 打开笔记的请求码
+    private final static int REQUEST_CODE_NEW_NODE  = 103; // 新建笔记的请求码
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        setContentView(R.layout.note_list);
-        initResources();
+        setContentView(R.layout.note_list); // 设置布局
+        initResources(); // 初始化资源
 
         /**
-         * Insert an introduction when user firstly use this application
+         * 当用户首次使用应用时插入介绍
          */
-        setAppInfoFromRawRes();
+        setAppInfoFromRawRes(); // 设置应用信息（首次使用时添加介绍笔记）
     }
 
     @Override
     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        // 处理从NoteEditActivity返回的结果
         if (resultCode == RESULT_OK
                 && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
+            // 如果是打开或新建笔记的请求返回成功，刷新列表
             mNotesListAdapter.changeCursor(null);
         } else {
             super.onActivityResult(requestCode, resultCode, data);
         }
     }
 
+/**
+     * 从原始资源文件中设置应用介绍信息
+     * 当用户首次使用应用时，添加介绍笔记
+     */
     private void setAppInfoFromRawRes() {
         SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
         if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
@@ -203,12 +207,20 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+    /**
+     * 当活动开始时调用
+     * 启动异步查询笔记列表
+     */
     @Override
     protected void onStart() {
         super.onStart();
         startAsyncNotesListQuery();
     }
 
+/**
+     * 初始化资源
+     * 设置内容解析器、异步查询处理器、列表适配器等
+     */
     private void initResources() {
         mContentResolver = this.getContentResolver();
         mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
@@ -231,11 +243,19 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         mModeCallBack = new ModeCallback();
     }
 
+/**
+     * 多选模式回调类 - 处理笔记的多选操作
+     * 实现了多选模式下的菜单创建、选择状态变化等功能
+     */
     private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
         private DropdownMenu mDropDownMenu;
         private ActionMode mActionMode;
         private MenuItem mMoveMenu;
 
+        /**
+         * 创建操作模式时调用
+         * 设置多选模式下的菜单和视图
+         */
         public boolean onCreateActionMode(ActionMode mode, Menu menu) {
             getMenuInflater().inflate(R.menu.note_list_options, menu);
             menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
@@ -269,6 +289,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
             return true;
         }
 
+        /**
+         * 更新菜单状态
+         * 根据选择的笔记数量更新下拉菜单标题和全选状态
+         */
         private void updateMenu() {
             int selectedCount = mNotesListAdapter.getSelectedCount();
             // Update dropdown menu
@@ -296,22 +320,37 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
             return false;
         }
 
+        /**
+         * 销毁操作模式时调用
+         * 恢复普通模式下的视图状态
+         */
         public void onDestroyActionMode(ActionMode mode) {
             mNotesListAdapter.setChoiceMode(false);
             mNotesListView.setLongClickable(true);
             mAddNewNote.setVisibility(View.VISIBLE);
         }
 
+        /**
+         * 结束操作模式
+         */
         public void finishActionMode() {
             mActionMode.finish();
         }
 
+        /**
+         * 当列表项的选择状态改变时调用
+         * 更新适配器中的选择状态并刷新菜单
+         */
         public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
                 boolean checked) {
             mNotesListAdapter.setCheckedItem(position, checked);
             updateMenu();
         }
 
+        /**
+         * 处理菜单项点击事件
+         * 支持删除和移动操作
+         */
         public boolean onMenuItemClick(MenuItem item) {
             if (mNotesListAdapter.getSelectedCount() == 0) {
                 Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
@@ -321,6 +360,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
 
             switch (item.getItemId()) {
                 case R.id.delete:
+                    // 显示删除确认对话框
                     AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                     builder.setTitle(getString(R.string.alert_title_delete));
                     builder.setIcon(android.R.drawable.ic_dialog_alert);
@@ -330,13 +370,14 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                                              new DialogInterface.OnClickListener() {
                                                  public void onClick(DialogInterface dialog,
                                                          int which) {
-                                                     batchDelete();
+                                                     batchDelete(); // 执行批量删除
                                                  }
                                              });
                     builder.setNegativeButton(android.R.string.cancel, null);
                     builder.show();
                     break;
                 case R.id.move:
+                    // 查询目标文件夹列表
                     startQueryDestinationFolders();
                     break;
                 default:
@@ -346,6 +387,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+/**
+     * 新建笔记按钮的触摸监听器
+     * 处理特殊的触摸事件分发逻辑
+     */
     private class NewNoteOnTouchListener implements OnTouchListener {
 
         public boolean onTouch(View v, MotionEvent event) {
@@ -408,6 +453,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
 
     };
 
+/**
+     * 开始异步查询笔记列表
+     * 根据当前文件夹ID选择不同的查询条件
+     */
     private void startAsyncNotesListQuery() {
         String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
                 : NORMAL_SELECTION;
@@ -417,18 +466,27 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
     }
 
+/**
+     * 后台查询处理器 - 处理异步数据库查询
+     */
     private final class BackgroundQueryHandler extends AsyncQueryHandler {
         public BackgroundQueryHandler(ContentResolver contentResolver) {
             super(contentResolver);
         }
 
+        /**
+         * 查询完成时调用
+         * 根据不同的查询标记处理查询结果
+         */
         @Override
         protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
             switch (token) {
                 case FOLDER_NOTE_LIST_QUERY_TOKEN:
+                    // 查询笔记列表完成，更新适配器
                     mNotesListAdapter.changeCursor(cursor);
                     break;
                 case FOLDER_LIST_QUERY_TOKEN:
+                    // 查询文件夹列表完成，显示文件夹菜单
                     if (cursor != null && cursor.getCount() > 0) {
                         showFolderListMenu(cursor);
                     } else {
@@ -441,6 +499,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+/**
+     * 显示文件夹列表菜单
+     * 用于选择移动笔记的目标文件夹
+     */
     private void showFolderListMenu(Cursor cursor) {
         AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
         builder.setTitle(R.string.menu_title_select_folder);
@@ -462,6 +524,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         builder.show();
     }
 
+/**
+     * 创建新笔记
+     * 跳转到笔记编辑界面
+     */
     private void createNewNote() {
         Intent intent = new Intent(this, NoteEditActivity.class);
         intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
@@ -469,6 +535,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
     }
 
+/**
+     * 批量删除笔记
+     * 在同步模式下将笔记移动到回收站，非同步模式下直接删除
+     */
     private void batchDelete() {
         new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
             protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
@@ -506,6 +576,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }.execute();
     }
 
+/**
+     * 删除文件夹
+     * 在同步模式下将文件夹移动到回收站，非同步模式下直接删除
+     */
     private void deleteFolder(long folderId) {
         if (folderId == Notes.ID_ROOT_FOLDER) {
             Log.e(TAG, "Wrong folder id, should not happen " + folderId);
@@ -533,6 +607,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+/**
+     * 打开笔记
+     * 跳转到笔记编辑界面查看/编辑笔记
+     */
     private void openNode(NoteItemData data) {
         Intent intent = new Intent(this, NoteEditActivity.class);
         intent.setAction(Intent.ACTION_VIEW);
@@ -540,6 +618,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
     }
 
+/**
+     * 打开文件夹
+     * 更新当前文件夹ID并重新查询笔记列表
+     */
     private void openFolder(NoteItemData data) {
         mCurrentFolderId = data.getId();
         startAsyncNotesListQuery();
@@ -557,6 +639,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         mTitleBar.setVisibility(View.VISIBLE);
     }
 
+/**
+     * 处理点击事件
+     * 当前只处理新建笔记按钮的点击
+     */
     public void onClick(View v) {
         switch (v.getId()) {
             case R.id.btn_new_note:
@@ -567,6 +653,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+/**
+     * 显示软键盘
+     */
     private void showSoftInput() {
         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
         if (inputMethodManager != null) {
@@ -574,11 +663,18 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+/**
+     * 隐藏软键盘
+     */
     private void hideSoftInput(View view) {
         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
         inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
     }
 
+/**
+     * 显示创建或修改文件夹的对话框
+     * @param create 是否为创建文件夹模式
+     */
     private void showCreateOrModifyFolderDialog(final boolean create) {
         final AlertDialog.Builder builder = new AlertDialog.Builder(this);
         View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
@@ -664,6 +760,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         });
     }
 
+    /**
+     * 处理返回键按下事件
+     * 根据当前状态返回到上一级菜单或退出应用
+     */
     @Override
     public void onBackPressed() {
         switch (mState) {
@@ -688,6 +788,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     }
 
+/**
+     * 更新小部件
+     * 根据小部件类型发送相应的广播更新
+     */
     private void updateWidget(int appWidgetId, int appWidgetType) {
         Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
         if (appWidgetType == Notes.TYPE_WIDGET_2X) {
@@ -707,6 +811,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         setResult(RESULT_OK, intent);
     }
 
+/**
+     * 文件夹上下文菜单监听器
+     * 创建文件夹的上下文菜单
+     */
     private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
         public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
             if (mFocusNoteDataItem != null) {
@@ -718,6 +826,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         }
     };
 
+    /**
+     * 上下文菜单关闭时调用
+     * 清除列表视图的上下文菜单监听器
+     */
     @Override
     public void onContextMenuClosed(Menu menu) {
         if (mNotesListView != null) {
@@ -726,6 +838,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         super.onContextMenuClosed(menu);
     }
 
+    /**
+     * 处理上下文菜单项的选择
+     * 支持查看、删除、重命名文件夹操作
+     */
     @Override
     public boolean onContextItemSelected(MenuItem item) {
         if (mFocusNoteDataItem == null) {
@@ -760,6 +876,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         return true;
     }
 
+    /**
+     * 准备选项菜单
+     * 根据当前状态加载不同的菜单布局
+     */
     @Override
     public boolean onPrepareOptionsMenu(Menu menu) {
         menu.clear();
@@ -778,6 +898,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         return true;
     }
 
+    /**
+     * 处理选项菜单项的选择
+     * 支持新建文件夹、导出文本、同步等操作
+     */
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
diff --git a/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java b/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
index 51c9cb9..7d6e7b4 100644
--- a/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
@@ -31,18 +31,31 @@ import java.util.HashSet;
 import java.util.Iterator;
 
 
+/**
+ * 笔记列表适配器类
+ * 继承自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;
-
+    private static final String TAG = "NotesListAdapter";  // 日志标签
+    private Context mContext;                               // 应用上下文
+    private HashMap<Integer, Boolean> mSelectedIndex;       // 存储选中项的索引映射
+    private int mNotesCount;                                // 笔记总数
+    private boolean mChoiceMode;                            // 是否处于选择模式
+
+    /**
+     * 应用小部件属性类
+     * 用于存储应用小部件的ID和类型信息
+     */
     public static class AppWidgetAttribute {
-        public int widgetId;
-        public int widgetType;
+        public int widgetId;     // 小部件ID
+        public int widgetType;   // 小部件类型
     };
 
+    /**
+     * 构造方法
+     * @param context 应用上下文
+     */
     public NotesListAdapter(Context context) {
         super(context, null);
         mSelectedIndex = new HashMap<Integer, Boolean>();
@@ -50,11 +63,25 @@ public class NotesListAdapter extends CursorAdapter {
         mNotesCount = 0;
     }
 
+    /**
+     * 创建新的视图
+     * @param context 应用上下文
+     * @param cursor 数据库游标
+     * @param parent 父视图组
+     * @return 新创建的NotesListItem视图
+     */
     @Override
     public View newView(Context context, Cursor cursor, ViewGroup parent) {
         return new NotesListItem(context);
     }
 
+    /**
+     * 绑定数据到视图
+     * 将数据库游标中的数据绑定到NotesListItem视图上
+     * @param view 要绑定的视图
+     * @param context 应用上下文
+     * @param cursor 数据库游标
+     */
     @Override
     public void bindView(View view, Context context, Cursor cursor) {
         if (view instanceof NotesListItem) {
@@ -64,24 +91,42 @@ public class NotesListAdapter extends CursorAdapter {
         }
     }
 
+    /**
+     * 设置指定位置的笔记项的选中状态
+     * @param position 笔记项的位置
+     * @param checked 选中状态，true为选中，false为未选中
+     */
     public void setCheckedItem(final int position, final boolean checked) {
         mSelectedIndex.put(position, checked);
         notifyDataSetChanged();
     }
 
+    /**
+     * 检查是否处于选择模式
+     * @return true表示处于选择模式，false表示非选择模式
+     */
     public boolean isInChoiceMode() {
         return mChoiceMode;
     }
 
+    /**
+     * 设置选择模式
+     * @param mode true为选择模式，false为非选择模式
+     */
     public void setChoiceMode(boolean mode) {
-        mSelectedIndex.clear();
+        mSelectedIndex.clear();  // 清除所有选中项
         mChoiceMode = mode;
     }
 
+    /**
+     * 选择或取消选择所有笔记项
+     * @param checked true为全选，false为取消全选
+     */
     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);
                 }
@@ -89,6 +134,10 @@ public class NotesListAdapter extends CursorAdapter {
         }
     }
 
+    /**
+     * 获取所有选中项的ID
+     * @return 包含所有选中项ID的HashSet
+     */
     public HashSet<Long> getSelectedItemIds() {
         HashSet<Long> itemSet = new HashSet<Long>();
         for (Integer position : mSelectedIndex.keySet()) {
@@ -105,6 +154,10 @@ public class NotesListAdapter extends CursorAdapter {
         return itemSet;
     }
 
+    /**
+     * 获取所有选中项的小部件属性
+     * @return 包含所有选中项小部件属性的HashSet
+     */
     public HashSet<AppWidgetAttribute> getSelectedWidget() {
         HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
         for (Integer position : mSelectedIndex.keySet()) {
@@ -128,6 +181,10 @@ public class NotesListAdapter extends CursorAdapter {
         return itemSet;
     }
 
+    /**
+     * 获取选中项的数量
+     * @return 选中项的数量
+     */
     public int getSelectedCount() {
         Collection<Boolean> values = mSelectedIndex.values();
         if (null == values) {
@@ -143,11 +200,20 @@ public class NotesListAdapter extends CursorAdapter {
         return count;
     }
 
+    /**
+     * 检查是否所有笔记项都被选中
+     * @return true表示所有笔记项都被选中，false表示不是
+     */
     public boolean isAllSelected() {
         int checkedCount = getSelectedCount();
         return (checkedCount != 0 && checkedCount == mNotesCount);
     }
 
+    /**
+     * 检查指定位置的笔记项是否被选中
+     * @param position 笔记项的位置
+     * @return true表示被选中，false表示未被选中
+     */
     public boolean isSelectedItem(final int position) {
         if (null == mSelectedIndex.get(position)) {
             return false;
@@ -158,20 +224,25 @@ public class NotesListAdapter extends CursorAdapter {
     @Override
     protected void onContentChanged() {
         super.onContentChanged();
-        calcNotesCount();
+        calcNotesCount();  // 重新计算笔记总数
     }
 
     @Override
     public void changeCursor(Cursor cursor) {
         super.changeCursor(cursor);
-        calcNotesCount();
+        calcNotesCount();  // 重新计算笔记总数
     }
 
+    /**
+     * 计算笔记总数
+     * 遍历所有游标项，统计类型为笔记的项的数量
+     */
     private void calcNotesCount() {
         mNotesCount = 0;
         for (int i = 0; i < getCount(); i++) {
             Cursor c = (Cursor) getItem(i);
             if (c != null) {
+                // 只统计类型为笔记的项
                 if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
                     mNotesCount++;
                 }
diff --git a/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java b/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
index 1221e80..2282d94 100644
--- a/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
@@ -30,17 +30,33 @@ import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
 
 
+/**
+ * 笔记列表项视图
+ * 用于在笔记列表中显示单个笔记项的自定义视图
+ */
 public class NotesListItem extends LinearLayout {
+    /** 提醒图标 */
     private ImageView mAlert;
+    /** 笔记标题文本视图 */
     private TextView mTitle;
+    /** 时间文本视图 */
     private TextView mTime;
+    /** 联系人姓名文本视图（用于通话记录） */
     private TextView mCallName;
+    /** 笔记项数据 */
     private NoteItemData mItemData;
+    /** 复选框（用于选择模式） */
     private CheckBox mCheckBox;
 
+    /**
+     * 创建一个笔记列表项视图实例
+     * @param context 上下文
+     */
     public NotesListItem(Context context) {
         super(context);
+        // 填充布局
         inflate(context, R.layout.note_item, this);
+        // 获取视图组件
         mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
         mTitle = (TextView) findViewById(R.id.tv_title);
         mTime = (TextView) findViewById(R.id.tv_time);
@@ -48,7 +64,15 @@ public class NotesListItem extends LinearLayout {
         mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
     }
 
+    /**
+     * 将笔记数据绑定到视图
+     * @param context 上下文
+     * @param data 笔记项数据
+     * @param choiceMode 是否为选择模式
+     * @param checked 是否被选中
+     */
     public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
+        // 处理选择模式下的复选框显示
         if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
             mCheckBox.setVisibility(View.VISIBLE);
             mCheckBox.setChecked(checked);
@@ -57,6 +81,8 @@ public class NotesListItem extends LinearLayout {
         }
 
         mItemData = data;
+        
+        // 处理通话记录文件夹
         if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
             mCallName.setVisibility(View.GONE);
             mAlert.setVisibility(View.VISIBLE);
@@ -64,7 +90,9 @@ public class NotesListItem extends LinearLayout {
             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) {
+        } 
+        // 处理通话记录笔记
+        else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
             mCallName.setVisibility(View.VISIBLE);
             mCallName.setText(data.getCallName());
             mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
@@ -75,16 +103,20 @@ public class NotesListItem extends LinearLayout {
             } else {
                 mAlert.setVisibility(View.GONE);
             }
-        } else {
+        } 
+        // 处理普通文件夹或笔记
+        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);
@@ -94,14 +126,23 @@ public class NotesListItem extends LinearLayout {
                 }
             }
         }
+        
+        // 设置修改时间
         mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
 
+        // 设置背景
         setBackground(data);
     }
 
+    /**
+     * 设置笔记项的背景
+     * @param data 笔记项数据
+     */
     private void setBackground(NoteItemData data) {
         int id = data.getBgColorId();
+        
         if (data.getType() == Notes.TYPE_NOTE) {
+            // 根据笔记在列表中的位置选择不同的背景
             if (data.isSingle() || data.isOneFollowingFolder()) {
                 setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
             } else if (data.isLast()) {
@@ -112,10 +153,15 @@ public class NotesListItem extends LinearLayout {
                 setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
             }
         } else {
+            // 文件夹使用固定背景
             setBackgroundResource(NoteItemBgResources.getFolderBgRes());
         }
     }
 
+    /**
+     * 获取笔记项数据
+     * @return 笔记项数据
+     */
     public NoteItemData getItemData() {
         return mItemData;
     }
diff --git a/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java b/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
index 07c5f7e..139238e 100644
--- a/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
@@ -48,55 +48,79 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.remote.GTaskSyncService;
 
 
+/**
+ * 设置活动，用于管理同步账户、最后同步时间和背景颜色偏好
+ */
 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;
 
+    /** 同步状态广播接收器 */
     private GTaskReceiver mReceiver;
 
+    /** 原始账户列表 */
     private Account[] mOriAccounts;
 
+    /** 是否添加了新账户 */
     private boolean mHasAddedAccount;
 
+    /**
+     * 创建活动时调用，初始化布局、偏好设置和广播接收器
+     * @param icicle 保存的实例状态
+     */
     @Override
     protected void onCreate(Bundle icicle) {
         super.onCreate(icicle);
 
-        /* using the app icon for navigation */
+        /* 使用应用图标作为导航 */
         getActionBar().setDisplayHomeAsUpEnabled(true);
 
+        // 从资源文件加载偏好设置
         addPreferencesFromResource(R.xml.preferences);
+        // 获取账户偏好分类
         mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+        // 创建并注册同步状态广播接收器
         mReceiver = new GTaskReceiver();
         IntentFilter filter = new IntentFilter();
         filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
         registerReceiver(mReceiver, filter);
 
         mOriAccounts = null;
+        // 加载设置头部布局
         View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
         getListView().addHeaderView(header, null, true);
     }
 
+    /**
+     * 活动恢复时调用，检查是否添加了新账户并刷新UI
+     */
     @Override
     protected void onResume() {
         super.onResume();
 
-        // need to set sync account automatically if user has added a new
-        // account
+        // 如果用户添加了新账户，则自动设置同步账户
         if (mHasAddedAccount) {
             Account[] accounts = getGoogleAccounts();
             if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
+                // 查找新增的账户
                 for (Account accountNew : accounts) {
                     boolean found = false;
                     for (Account accountOld : mOriAccounts) {
@@ -106,6 +130,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                         }
                     }
                     if (!found) {
+                        // 设置新增账户为同步账户
                         setSyncAccount(accountNew.name);
                         break;
                     }
@@ -113,36 +138,48 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             }
         }
 
+        // 刷新UI界面
         refreshUI();
     }
 
+    /**
+     * 活动销毁时调用，取消注册广播接收器
+     */
     @Override
     protected void onDestroy() {
+        // 取消注册同步状态广播接收器
         if (mReceiver != null) {
             unregisterReceiver(mReceiver);
         }
         super.onDestroy();
     }
 
+    /**
+     * 加载账户偏好设置，创建账户选择偏好项
+     */
     private void loadAccountPreference() {
+        // 清空账户偏好分类中的所有项
         mAccountCategory.removeAll();
 
+        // 创建账户选择偏好项
         Preference accountPref = new Preference(this);
         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() {
             public boolean onPreferenceClick(Preference preference) {
+                // 只有当不同步时才能更改账户
                 if (!GTaskSyncService.isSyncing()) {
                     if (TextUtils.isEmpty(defaultAccount)) {
-                        // the first time to set account
+                        // 首次设置账户，显示账户选择对话框
                         showSelectAccountAlertDialog();
                     } else {
-                        // if the account has already been set, we need to promp
-                        // user about the risk
+                        // 已设置账户，显示更改账户确认对话框
                         showChangeAccountConfirmAlertDialog();
                     }
                 } else {
+                    // 同步中不能更改账户，显示提示信息
                     Toast.makeText(NotesPreferenceActivity.this,
                             R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
                             .show();
@@ -151,85 +188,113 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             }
         });
 
+        // 将账户偏好项添加到分类中
         mAccountCategory.addPreference(accountPref);
     }
 
+    /**
+     * 加载同步按钮和最后同步时间显示
+     */
     private void loadSyncButton() {
+        // 获取同步按钮和最后同步时间文本视图
         Button syncButton = (Button) findViewById(R.id.preference_sync_button);
         TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
 
-        // set button state
+        // 设置同步按钮状态
         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)));
 
-        // set last sync time
+        // 设置最后同步时间显示
         if (GTaskSyncService.isSyncing()) {
+            // 同步中，显示同步进度
             lastSyncTimeView.setText(GTaskSyncService.getProgressString());
             lastSyncTimeView.setVisibility(View.VISIBLE);
         } else {
+            // 未同步，显示最后同步时间
             long lastSyncTime = getLastSyncTime(this);
             if (lastSyncTime != 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);
             } else {
+                // 从未同步过，隐藏时间显示
                 lastSyncTimeView.setVisibility(View.GONE);
             }
         }
     }
 
+    /**
+     * 刷新UI界面，重新加载账户偏好和同步按钮
+     */
     private void refreshUI() {
         loadAccountPreference();
         loadSyncButton();
     }
 
+    /**
+     * 显示选择账户的对话框，允许用户选择已有账户或添加新账户
+     */
     private void showSelectAccountAlertDialog() {
         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
 
+        // 加载自定义标题视图
         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);
 
+        // 获取所有Google账户
         Account[] accounts = getGoogleAccounts();
         String defAccount = getSyncAccountName(this);
 
+        // 保存原始账户列表和添加账户标志
         mOriAccounts = accounts;
         mHasAddedAccount = 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();
@@ -237,13 +302,17 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                     });
         }
 
+        // 加载添加账户视图
         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;
+                // 打开添加账户设置界面
                 Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
                 intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
                     "gmail-ls"
@@ -254,9 +323,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         });
     }
 
+    /**
+     * 显示更改账户的确认对话框，提醒用户更改账户的风险
+     */
     private void showChangeAccountConfirmAlertDialog() {
         AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
 
+        // 加载自定义标题视图
         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,
@@ -265,31 +338,46 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         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();
     }
 
+    /**
+     * 获取设备上所有的Google账户
+     * @return Google账户数组
+     */
     private Account[] getGoogleAccounts() {
         AccountManager accountManager = AccountManager.get(this);
         return accountManager.getAccountsByType("com.google");
     }
 
+    /**
+     * 设置同步账户，并清理相关的本地同步信息
+     * @param account 要设置的账户名
+     */
     private void setSyncAccount(String account) {
+        // 只有当账户名不同时才更新
         if (!getSyncAccountName(this).equals(account)) {
+            // 更新账户偏好设置
             SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
             SharedPreferences.Editor editor = settings.edit();
             if (account != null) {
@@ -299,10 +387,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             }
             editor.commit();
 
-            // clean up last sync time
+            // 清除最后同步时间
             setLastSyncTime(this, 0);
 
-            // clean up local gtask related info
+            // 在后台线程中清除本地Google Tasks相关信息
             new Thread(new Runnable() {
                 public void run() {
                     ContentValues values = new ContentValues();
@@ -312,13 +400,18 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                 }
             }).start();
 
+            // 显示设置成功提示
             Toast.makeText(NotesPreferenceActivity.this,
                     getString(R.string.preferences_toast_success_set_accout, account),
                     Toast.LENGTH_SHORT).show();
         }
     }
 
+    /**
+     * 移除同步账户，并清理相关的本地同步信息
+     */
     private void removeSyncAccount() {
+        // 清除账户偏好设置和最后同步时间
         SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
         SharedPreferences.Editor editor = settings.edit();
         if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
@@ -329,7 +422,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
         editor.commit();
 
-        // clean up local gtask related info
+        // 在后台线程中清除本地Google Tasks相关信息
         new Thread(new Runnable() {
             public void run() {
                 ContentValues values = new ContentValues();
@@ -340,12 +433,22 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }).start();
     }
 
+    /**
+     * 获取当前同步账户名
+     * @param context 上下文
+     * @return 当前同步账户名，若无则返回空字符串
+     */
     public static String getSyncAccountName(Context context) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
         return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
     }
 
+    /**
+     * 设置最后同步时间
+     * @param context 上下文
+     * @param time 最后同步时间的时间戳
+     */
     public static void setLastSyncTime(Context context, long time) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
@@ -354,17 +457,32 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         editor.commit();
     }
 
+    /**
+     * 获取最后同步时间
+     * @param context 上下文
+     * @return 最后同步时间的时间戳，若无则返回0
+     */
     public static long getLastSyncTime(Context context) {
         SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                 Context.MODE_PRIVATE);
         return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
     }
 
+    /**
+     * 同步状态广播接收器，监听同步状态变化并更新UI
+     */
     private class GTaskReceiver extends BroadcastReceiver {
 
+        /**
+         * 接收到广播时调用
+         * @param context 上下文
+         * @param intent 包含同步状态信息的意图
+         */
         @Override
         public void onReceive(Context context, Intent intent) {
+            // 刷新UI
             refreshUI();
+            // 如果正在同步，更新同步状态文本
             if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
                 TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
                 syncStatus.setText(intent
@@ -374,9 +492,15 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
     }
 
+    /**
+     * 处理选项菜单的点击事件
+     * @param item 被点击的菜单项
+     * @return true表示事件已处理，false表示未处理
+     */
     public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
             case android.R.id.home:
+                // 点击返回按钮，返回笔记列表活动
                 Intent intent = new Intent(this, NotesListActivity.class);
                 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                 startActivity(intent);
diff --git a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
index ec6f819..0bcdc41 100644
--- a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
@@ -32,101 +32,168 @@ import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.ui.NoteEditActivity;
 import net.micode.notes.ui.NotesListActivity;
 
+/**
+ * 抽象的笔记小部件提供者类，用于创建和管理笔记应用的桌面小部件
+ */
 public abstract class NoteWidgetProvider extends AppWidgetProvider {
+    /** 数据库查询投影，包含笔记ID、背景颜色ID和摘要 */
     public static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,
-        NoteColumns.BG_COLOR_ID,
-        NoteColumns.SNIPPET
+        NoteColumns.ID,          // 笔记ID
+        NoteColumns.BG_COLOR_ID, // 背景颜色ID
+        NoteColumns.SNIPPET      // 笔记摘要
     };
 
+    /** 投影列索引 - 笔记ID */
     public static final int COLUMN_ID           = 0;
+    /** 投影列索引 - 背景颜色ID */
     public static final int COLUMN_BG_COLOR_ID  = 1;
+    /** 投影列索引 - 笔记摘要 */
     public static final int COLUMN_SNIPPET      = 2;
 
+    /** 日志标签 */
     private static final String TAG = "NoteWidgetProvider";
 
+    /**
+     * 当小部件被删除时调用，清除与该小部件关联的笔记信息
+     * @param context 上下文
+     * @param appWidgetIds 被删除的小部件ID数组
+     */
     @Override
     public void onDeleted(Context context, int[] appWidgetIds) {
+        // 创建要更新的内容值，将WIDGET_ID设置为无效值
         ContentValues values = new ContentValues();
         values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
+        
+        // 遍历所有被删除的小部件ID
         for (int i = 0; i < appWidgetIds.length; i++) {
+            // 更新与小部件关联且不在回收站中的笔记，清除其WIDGET_ID
             context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
                     values,
-                    NoteColumns.WIDGET_ID + "=?",
-                    new String[] { String.valueOf(appWidgetIds[i])});
+                    NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
+                    new String[] { String.valueOf(appWidgetIds[i]), String.valueOf(Notes.ID_TRASH_FOLER) });
         }
     }
 
+    /**
+     * 获取与指定小部件关联的笔记信息
+     * @param context 上下文
+     * @param widgetId 小部件ID
+     * @return 包含笔记信息的Cursor，若无则返回null
+     */
     private Cursor getNoteWidgetInfo(Context context, int widgetId) {
+        // 查询与指定小部件ID关联且不在回收站中的笔记
         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);
+                PROJECTION, // 查询的列
+                NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?", // 查询条件
+                new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) }, // 参数值
+                null); // 排序方式
     }
 
+    /**
+     * 更新小部件内容的公共方法，默认非隐私模式
+     * @param context 上下文
+     * @param appWidgetManager 小部件管理器
+     * @param appWidgetIds 要更新的小部件ID数组
+     */
     protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
         update(context, appWidgetManager, appWidgetIds, false);
     }
 
+    /**
+     * 更新小部件内容的私有方法，支持隐私模式
+     * @param context 上下文
+     * @param appWidgetManager 小部件管理器
+     * @param appWidgetIds 要更新的小部件ID数组
+     * @param privacyMode 是否为隐私模式
+     */
     private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
             boolean privacyMode) {
+        // 遍历所有小部件ID
         for (int i = 0; i < appWidgetIds.length; i++) {
+            // 只处理有效的小部件ID
             if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
+                // 默认背景颜色
                 int bgId = ResourceParser.getDefaultBgId(context);
                 String snippet = "";
+                
+                // 创建跳转到笔记编辑活动的意图
                 Intent intent = new Intent(context, NoteEditActivity.class);
-                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
-                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
-                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
+                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); // 避免创建新的活动实例
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]); // 传递小部件ID
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType()); // 传递小部件类型
 
+                // 获取与小部件关联的笔记信息
                 Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
                 if (c != null && c.moveToFirst()) {
+                    // 检查是否有多个笔记与同一小部件关联
                     if (c.getCount() > 1) {
                         Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
                         c.close();
                         return;
                     }
+                    
+                    // 获取笔记信息
                     snippet = c.getString(COLUMN_SNIPPET);
                     bgId = c.getInt(COLUMN_BG_COLOR_ID);
-                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
-                    intent.setAction(Intent.ACTION_VIEW);
+                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID)); // 传递笔记ID
+                    intent.setAction(Intent.ACTION_VIEW); // 设置操作为查看
                 } else {
+                    // 无关联笔记，显示默认提示文本
                     snippet = context.getResources().getString(R.string.widget_havenot_content);
-                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT); // 设置操作为插入或编辑
                 }
 
+                // 关闭Cursor
                 if (c != null) {
                     c.close();
                 }
 
+                // 创建RemoteViews以更新小部件UI
                 RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
-                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
-                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
+                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId)); // 设置背景图片
+                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId); // 传递背景颜色ID
+                
                 /**
-                 * Generate the pending intent to start host for the widget
+                 * 生成小部件点击的PendingIntent
                  */
                 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);
                 } else {
+                    // 正常模式下，显示笔记摘要并跳转到笔记编辑
                     rv.setTextViewText(R.id.widget_text, snippet);
                     pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
                             PendingIntent.FLAG_UPDATE_CURRENT);
                 }
 
+                // 设置小部件点击事件
                 rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
+                // 更新小部件
                 appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
             }
         }
     }
 
+    /**
+     * 获取对应背景颜色ID的资源ID
+     * @param bgId 背景颜色ID
+     * @return 背景图片资源ID
+     */
     protected abstract int getBgResourceId(int bgId);
 
+    /**
+     * 获取小部件布局的资源ID
+     * @return 布局资源ID
+     */
     protected abstract int getLayoutId();
 
+    /**
+     * 获取小部件类型
+     * @return 小部件类型
+     */
     protected abstract int getWidgetType();
 }
diff --git a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
index adcb2f7..1b36e8a 100644
--- a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
@@ -24,22 +24,45 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 
 
+/**
+ * 2x2 大小的笔记小部件提供者类
+ */
 public class NoteWidgetProvider_2x extends NoteWidgetProvider {
+    /**
+     * 当小部件需要更新时调用
+     * @param context 上下文
+     * @param appWidgetManager 小部件管理器
+     * @param appWidgetIds 要更新的小部件ID数组
+     */
     @Override
     public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用父类的update方法更新小部件
         super.update(context, appWidgetManager, appWidgetIds);
     }
 
+    /**
+     * 获取2x2小部件的布局资源ID
+     * @return 布局资源ID
+     */
     @Override
     protected int getLayoutId() {
         return R.layout.widget_2x;
     }
 
+    /**
+     * 获取2x2小部件对应背景颜色ID的资源ID
+     * @param bgId 背景颜色ID
+     * @return 背景图片资源ID
+     */
     @Override
     protected int getBgResourceId(int bgId) {
         return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
     }
 
+    /**
+     * 获取2x2小部件的类型
+     * @return 小部件类型常量
+     */
     @Override
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_2X;
diff --git a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
index c12a02e..3eea979 100644
--- a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
@@ -24,21 +24,45 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 
 
+/**
+ * 4x4 大小的笔记小部件提供者类
+ */
 public class NoteWidgetProvider_4x extends NoteWidgetProvider {
+    /**
+     * 当小部件需要更新时调用
+     * @param context 上下文
+     * @param appWidgetManager 小部件管理器
+     * @param appWidgetIds 要更新的小部件ID数组
+     */
     @Override
     public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用父类的update方法更新小部件
         super.update(context, appWidgetManager, appWidgetIds);
     }
 
+    /**
+     * 获取4x4小部件的布局资源ID
+     * @return 布局资源ID
+     */
+    @Override
     protected int getLayoutId() {
         return R.layout.widget_4x;
     }
 
+    /**
+     * 获取4x4小部件对应背景颜色ID的资源ID
+     * @param bgId 背景颜色ID
+     * @return 背景图片资源ID
+     */
     @Override
     protected int getBgResourceId(int bgId) {
         return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
     }
 
+    /**
+     * 获取4x4小部件的类型
+     * @return 小部件类型常量
+     */
     @Override
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_4X;