bj

java/net/micode/notes/data/Contact.java

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: Contact.java
+ * 描述: 提供联系人相关功能的工具类，主要用于通过电话号码查询联系人姓名
+ * 作用: 在便签应用中，当用户创建通话记录便签时，需要显示联系人姓名而不仅仅是电话号码
+ */
 package net.micode.notes.data;
 
 import android.content.Context;
@@ -25,10 +30,24 @@ import android.util.Log;
 
 import java.util.HashMap;
 
+/**
+ * 联系人工具类
+ * 
+ * 提供通过电话号码查询联系人姓名的功能，使用缓存机制提高查询效率
+ */
 public class Contact {
+    /** 联系人缓存，键为电话号码，值为联系人姓名 */
     private static HashMap<String, String> sContactCache;
+    
+    /** 日志标签 */
     private static final String TAG = "Contact";
 
+    /**
+     * SQL查询条件，用于通过电话号码查询联系人
+     * 使用PHONE_NUMBERS_EQUAL函数比较电话号码
+     * 限制MIMETYPE为电话类型
+     * 通过phone_lookup表的min_match字段进行匹配
+     */
     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 "
@@ -36,17 +55,29 @@ public class Contact {
             + " FROM phone_lookup"
             + " WHERE min_match = '+')";
 
+    /**
+     * 通过电话号码获取联系人姓名
+     * 
+     * @param context 上下文环境，用于访问ContentResolver
+     * @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);
         }
 
+        // 替换SQL查询条件中的占位符，转换电话号码为标准格式
         String selection = CALLER_ID_SELECTION.replace("+",
                 PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+                
+        // 执行查询，获取联系人姓名
         Cursor cursor = context.getContentResolver().query(
                 Data.CONTENT_URI,
                 new String [] { Phone.DISPLAY_NAME },
@@ -54,18 +85,23 @@ public class Contact {
                 new String[] { phoneNumber },
                 null);
 
+        // 处理查询结果
         if (cursor != null && cursor.moveToFirst()) {
             try {
+                // 获取联系人姓名并存入缓存
                 String name = cursor.getString(0);
                 sContactCache.put(phoneNumber, name);
                 return name;
             } catch (IndexOutOfBoundsException e) {
+                // 处理索引越界异常
                 Log.e(TAG, " Cursor get string error " + e.toString());
                 return null;
             } finally {
+                // 确保关闭游标，释放资源
                 cursor.close();
             }
         } else {
+            // 未找到匹配的联系人
             Log.d(TAG, "No contact matched with number:" + phoneNumber);
             return null;
         }

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

@@ -14,14 +14,41 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: Notes.java
+ * 描述: 定义了便签应用的核心数据结构和常量
+ * 作用: 提供数据库表结构的定义、内容提供者URI、系统文件夹ID等常量，是应用数据层的核心定义文件
+ */
 package net.micode.notes.data;
 
 import android.net.Uri;
+
+/**
+ * 便签数据定义类
+ * 
+ * 包含了便签应用所有的数据常量定义，包括：
+ * - 内容提供者权限名称
+ * - 便签和文件夹类型
+ * - 系统文件夹ID
+ * - Intent传递参数的键名
+ * - 小部件类型
+ * - 数据库表列名
+ * - 内容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;
 
     /**
@@ -30,37 +57,73 @@ public class Notes {
      * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
      * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
      */
+    /** 系统文件夹ID：根文件夹（默认文件夹） */
     public static final int ID_ROOT_FOLDER = 0;
+    
+    /** 系统文件夹ID：临时文件夹（不属于任何文件夹的便签） */
     public static final int ID_TEMPARAY_FOLDER = -1;
+    
+    /** 系统文件夹ID：通话记录文件夹 */
     public static final int ID_CALL_RECORD_FOLDER = -2;
+    
+    /** 系统文件夹ID：回收站文件夹 */
     public static final int ID_TRASH_FOLER = -3;
 
+    /** Intent参数：提醒日期 */
     public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
+    
+    /** Intent参数：背景颜色ID */
     public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
+    
+    /** Intent参数：小部件ID */
     public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
+    
+    /** Intent参数：小部件类型 */
     public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
+    
+    /** Intent参数：文件夹ID */
     public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
+    
+    /** Intent参数：通话日期 */
     public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
 
+    /** 小部件类型：无效 */
     public static final int TYPE_WIDGET_INVALIDE      = -1;
+    
+    /** 小部件类型：2x小部件 */
     public static final int TYPE_WIDGET_2X            = 0;
+    
+    /** 小部件类型：4x小部件 */
     public static final int TYPE_WIDGET_4X            = 1;
 
+    /**
+     * 数据常量类
+     * 定义了便签内容类型的MIME类型常量
+     */
     public static class DataConstants {
+        /** 文本便签的MIME类型 */
         public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
+        
+        /** 通话记录便签的MIME类型 */
         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");
 
+    /**
+     * 便签表列名接口
+     * 定义了note表中所有列的名称和类型
+     */
     public interface NoteColumns {
         /**
          * The unique ID for a row
@@ -167,6 +230,10 @@ public class Notes {
         public static final String VERSION = "version";
     }
 
+    /**
+     * 数据表列名接口
+     * 定义了data表中所有列的名称和类型
+     */
     public interface DataColumns {
         /**
          * The unique ID for a row
@@ -241,6 +308,10 @@ public class Notes {
         public static final String DATA5 = "data5";
     }
 
+    /**
+     * 文本便签类
+     * 定义了文本便签特有的数据结构和常量
+     */
     public static final class TextNote implements DataColumns {
         /**
          * Mode to indicate the text in check list mode or not
@@ -248,15 +319,23 @@ public class Notes {
          */
         public static final String MODE = DATA1;
 
+        /** 便签模式：清单模式（可勾选的项目列表） */
         public static final int MODE_CHECK_LIST = 1;
 
+        /** 文本便签内容类型：多条记录 */
         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
 
+        /** 文本便签内容类型：单条记录 */
         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
 
+        /** 文本便签内容URI */
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
     }
 
+    /**
+     * 通话记录便签类
+     * 定义了通话记录便签特有的数据结构和常量
+     */
     public static final class CallNote implements DataColumns {
         /**
          * Call date for this record
@@ -270,10 +349,13 @@ public class Notes {
          */
         public static final String PHONE_NUMBER = DATA3;
 
+        /** 通话记录便签内容类型：多条记录 */
         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
 
+        /** 通话记录便签内容类型：单条记录 */
         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
 
+        /** 通话记录便签内容URI */
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
     }
 }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NotesDatabaseHelper.java
+ * 描述: 便签应用的数据库帮助类，负责创建和管理SQLite数据库
+ * 作用: 提供数据库的创建、升级和表结构管理，是应用数据持久化的核心组件
+ */
 package net.micode.notes.data;
 
 import android.content.ContentValues;
@@ -26,22 +31,42 @@ import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.DataConstants;
 import net.micode.notes.data.Notes.NoteColumns;
 
-
+/**
+ * 便签数据库帮助类
+ * 
+ * 继承自SQLiteOpenHelper，负责便签应用数据库的创建、升级和管理
+ * 提供了便签表和数据表的创建与管理，以及各种数据库触发器的定义
+ * 使用单例模式确保全局只有一个数据库连接实例
+ */
 public class NotesDatabaseHelper extends SQLiteOpenHelper {
+    /** 数据库名称 */
     private static final String DB_NAME = "note.db";
 
+    /** 数据库版本号 */
     private static final int DB_VERSION = 4;
 
+    /**
+     * 表名常量接口
+     * 定义了数据库中的表名
+     */
     public interface TABLE {
+        /** 便签表名 */
         public static final String NOTE = "note";
 
+        /** 数据表名 */
         public static final String DATA = "data";
     }
 
+    /** 日志标签 */
     private static final String TAG = "NotesDatabaseHelper";
 
+    /** 单例实例 */
     private static NotesDatabaseHelper mInstance;
 
+    /**
+     * 创建便签表的SQL语句
+     * 定义了便签表的结构，包括各列名和默认值
+     */
     private static final String CREATE_NOTE_TABLE_SQL =
         "CREATE TABLE " + TABLE.NOTE + "(" +
             NoteColumns.ID + " INTEGER PRIMARY KEY," +
@@ -63,6 +88,10 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
             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," +
@@ -78,12 +107,17 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
             DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
         ")";
 
+    /**
+     * 创建数据表NOTE_ID索引的SQL语句
+     * 用于优化按便签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 + ");";
 
     /**
-     * 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 "+
@@ -95,7 +129,8 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " 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 +143,8 @@ 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 +156,8 @@ 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 +170,8 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * Update note's content when insert data with type {@link DataConstants#NOTE}
+     * 更新便签内容的触发器
+     * 当插入类型为NOTE的数据时，自动更新对应便签的摘要内容
      */
     private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
         "CREATE TRIGGER update_note_content_on_insert " +
@@ -146,7 +184,8 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * Update note's content when data with {@link DataConstants#NOTE} type has changed
+     * 更新便签内容的触发器
+     * 当更新类型为NOTE的数据时，自动更新对应便签的摘要内容
      */
     private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
         "CREATE TRIGGER update_note_content_on_update " +
@@ -159,7 +198,8 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         " END";
 
     /**
-     * Update note's content when data with {@link DataConstants#NOTE} type has deleted
+     * 更新便签内容的触发器
+     * 当删除类型为NOTE的数据时，自动清空对应便签的摘要内容
      */
     private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
         "CREATE TRIGGER update_note_content_on_delete " +
@@ -172,7 +212,8 @@ 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 +224,8 @@ 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 +236,8 @@ 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 +249,38 @@ 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) {
+        // 执行创建便签表的SQL语句
         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 +289,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,12 +299,19 @@ 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);
@@ -248,6 +319,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         /**
          * root folder which is default folder
          */
+        // 创建根文件夹（默认文件夹）
         values.clear();
         values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
@@ -256,6 +328,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         /**
          * temporary folder which is used for moving note
          */
+        // 创建临时文件夹（用于移动便签）
         values.clear();
         values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
@@ -264,29 +337,52 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         /**
          * create trash folder
          */
+        // 创建回收站文件夹
         values.clear();
         values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
         db.insert(TABLE.NOTE, null, values);
     }
 
+    /**
+     * 创建数据表
+     * 
+     * @param db 数据库对象
+     */
     public void createDataTable(SQLiteDatabase db) {
+        // 执行创建数据表的SQL语句
         db.execSQL(CREATE_DATA_TABLE_SQL);
+        // 重新创建数据表的触发器
         reCreateDataTableTriggers(db);
+        // 创建数据表的索引
         db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
         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,68 +390,108 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         return mInstance;
     }
 
+    /**
+     * 数据库创建回调方法
+     * 当数据库首次创建时调用
+     * 
+     * @param db 数据库对象
+     */
     @Override
     public void onCreate(SQLiteDatabase 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;
 
+        // 从版本1升级到版本2
         if (oldVersion == 1) {
             upgradeToV2(db);
-            skipV2 = true; // this upgrade including the upgrade from v2 to v3
+            skipV2 = true; // 这个升级包含了从v2到v3的升级
             oldVersion++;
         }
 
+        // 从版本2升级到版本3
         if (oldVersion == 2 && !skipV2) {
             upgradeToV3(db);
             reCreateTriggers = true;
             oldVersion++;
         }
 
+        // 从版本3升级到版本4
         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");
         }
     }
 
+    /**
+     * 升级到版本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
+     * 添加Google Tasks ID列和回收站文件夹
+     * 
+     * @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
+        // 添加Google Tasks 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");
     }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NotesProvider.java
+ * 描述: 便签应用的内容提供者，负责管理便签数据的访问
+ * 作用: 为应用程序和其他应用提供便签数据的统一访问接口，实现数据的增删改查操作
+ */
 package net.micode.notes.data;
 
 
@@ -34,24 +39,41 @@ import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 
-
+/**
+ * 便签内容提供者类
+ * 
+ * 继承自ContentProvider，负责处理对便签数据的访问请求
+ * 实现了标准的CRUD操作（创建、读取、更新、删除）
+ * 支持便签搜索功能
+ */
 public class NotesProvider extends ContentProvider {
+    /** URI匹配器，用于匹配请求的URI类型 */
     private static final UriMatcher mMatcher;
 
+    /** 数据库帮助类实例 */
     private NotesDatabaseHelper mHelper;
 
+    /** 日志标签 */
     private static final String TAG = "NotesProvider";
 
+    /** 便签表URI类型 */
     private static final int URI_NOTE            = 1;
+    /** 单个便签项URI类型 */
     private static final int URI_NOTE_ITEM       = 2;
+    /** 数据表URI类型 */
     private static final int URI_DATA            = 3;
+    /** 单个数据项URI类型 */
     private static final int URI_DATA_ITEM       = 4;
 
+    /** 搜索URI类型 */
     private static final int URI_SEARCH          = 5;
+    /** 搜索建议URI类型 */
     private static final int URI_SEARCH_SUGGEST  = 6;
 
+    // 静态初始化块，配置URI匹配器
     static {
         mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        // 添加各种URI匹配规则
         mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
         mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
         mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
@@ -62,8 +84,9 @@ public class NotesProvider extends ContentProvider {
     }
 
     /**
-     * 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'字符。为了在搜索结果中显示更多信息，
+     * 我们会删除标题和内容中的'\n'和空格。
      */
     private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
         + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
@@ -73,50 +96,79 @@ public class NotesProvider extends ContentProvider {
         + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
         + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
 
+    /**
+     * 便签片段搜索查询SQL
+     * 用于搜索便签内容，排除回收站中的便签和非便签类型的项目
+     */
     private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
         + " FROM " + TABLE.NOTE
         + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
         + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
         + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
 
+    /**
+     * 内容提供者初始化
+     * 
+     * @return 初始化是否成功
+     */
     @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) {
         Cursor c = null;
+        // 获取可读数据库
         SQLiteDatabase db = mHelper.getReadableDatabase();
         String id = null;
+        
+        // 根据URI类型执行不同的查询操作
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
+                // 查询便签表
                 c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
             case URI_NOTE_ITEM:
+                // 查询单个便签项
                 id = uri.getPathSegments().get(1);
                 c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
             case URI_DATA:
+                // 查询数据表
                 c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
             case URI_DATA_ITEM:
+                // 查询单个数据项
                 id = uri.getPathSegments().get(1);
                 c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
             case URI_SEARCH:
             case URI_SEARCH_SUGGEST:
+                // 处理搜索和搜索建议请求
                 if (sortOrder != null || projection != null) {
                     throw new IllegalArgumentException(
                             "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
                 }
 
+                // 获取搜索字符串
                 String searchString = null;
                 if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
                     if (uri.getPathSegments().size() > 1) {
@@ -126,12 +178,14 @@ public class NotesProvider extends ContentProvider {
                     searchString = uri.getQueryParameter("pattern");
                 }
 
+                // 如果搜索字符串为空，则返回null
                 if (TextUtils.isEmpty(searchString)) {
                     return null;
                 }
 
+                // 执行搜索查询
                 try {
-                    searchString = String.format("%%%s%%", searchString);
+                    searchString = String.format("%%%s%%", searchString); // 添加通配符以进行模糊匹配
                     c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
                             new String[] { searchString });
                 } catch (IllegalStateException ex) {
@@ -141,21 +195,35 @@ public class NotesProvider extends ContentProvider {
             default:
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
+        
+        // 设置通知URI，当数据变化时通知观察者
         if (c != null) {
             c.setNotificationUri(getContext().getContentResolver(), uri);
         }
         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;
+        
+        // 根据URI类型执行不同的插入操作
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
+                // 插入便签
                 insertedId = noteId = db.insert(TABLE.NOTE, null, values);
                 break;
             case URI_DATA:
+                // 插入数据
                 if (values.containsKey(DataColumns.NOTE_ID)) {
                     noteId = values.getAsLong(DataColumns.NOTE_ID);
                 } else {
@@ -166,13 +234,14 @@ 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,22 +250,34 @@ 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;
         String id = null;
+        // 获取可写数据库
         SQLiteDatabase db = mHelper.getWritableDatabase();
         boolean deleteData = false;
+        
+        // 根据URI类型执行不同的删除操作
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
+                // 删除便签，ID必须大于0（系统文件夹ID小于等于0）
                 selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
                 count = db.delete(TABLE.NOTE, selection, selectionArgs);
                 break;
             case URI_NOTE_ITEM:
+                // 删除单个便签项
                 id = uri.getPathSegments().get(1);
                 /**
-                 * ID that smaller than 0 is system folder which is not allowed to
+                 * ID小于0的是系统文件夹，不允许删除
-                 * trash
                  */
                 long noteId = Long.valueOf(id);
                 if (noteId <= 0) {
@@ -206,10 +287,12 @@ public class NotesProvider extends ContentProvider {
                         NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
                 break;
             case URI_DATA:
+                // 删除数据
                 count = db.delete(TABLE.DATA, selection, selectionArgs);
                 deleteData = true;
                 break;
             case URI_DATA_ITEM:
+                // 删除单个数据项
                 id = uri.getPathSegments().get(1);
                 count = db.delete(TABLE.DATA,
                         DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
@@ -218,6 +301,8 @@ public class NotesProvider extends ContentProvider {
             default:
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
+        
+        // 如果有删除操作，通知观察者
         if (count > 0) {
             if (deleteData) {
                 getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
@@ -227,28 +312,44 @@ 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;
+        
+        // 根据URI类型执行不同的更新操作
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
-                increaseNoteVersion(-1, selection, selectionArgs);
+                // 更新便签表
+                increaseNoteVersion(-1, selection, selectionArgs); // 增加便签版本号
                 count = db.update(TABLE.NOTE, values, selection, selectionArgs);
                 break;
             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:
+                // 更新数据表
                 count = db.update(TABLE.DATA, values, selection, selectionArgs);
                 updateData = true;
                 break;
             case URI_DATA_ITEM:
+                // 更新单个数据项
                 id = uri.getPathSegments().get(1);
                 count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs);
@@ -258,6 +359,7 @@ public class NotesProvider extends ContentProvider {
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
 
+        // 如果有更新操作，通知观察者
         if (count > 0) {
             if (updateData) {
                 getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
@@ -267,11 +369,27 @@ public class NotesProvider extends ContentProvider {
         return count;
     }
 
+    /**
+     * 解析选择条件
+     * 将额外的选择条件添加到现有条件中
+     * 
+     * @param selection 选择条件
+     * @return 解析后的选择条件
+     */
     private String parseSelection(String selection) {
         return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
     }
 
+    /**
+     * 增加便签版本号
+     * 当便签内容更新时，增加版本号以便于同步
+     * 
+     * @param id 便签ID，如果为-1则使用selection和selectionArgs
+     * @param selection 选择条件
+     * @param selectionArgs 选择条件参数
+     */
     private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+        // 构建更新版本号的SQL语句
         StringBuilder sql = new StringBuilder(120);
         sql.append("UPDATE ");
         sql.append(TABLE.NOTE);
@@ -279,6 +397,7 @@ public class NotesProvider extends ContentProvider {
         sql.append(NoteColumns.VERSION);
         sql.append("=" + NoteColumns.VERSION + "+1 ");
 
+        // 添加WHERE条件
         if (id > 0 || !TextUtils.isEmpty(selection)) {
             sql.append(" WHERE ");
         }
@@ -287,19 +406,26 @@ public class NotesProvider extends ContentProvider {
         }
         if (!TextUtils.isEmpty(selection)) {
             String selectString = id > 0 ? parseSelection(selection) : selection;
+            // 替换参数占位符
             for (String args : selectionArgs) {
                 selectString = selectString.replaceFirst("\\?", args);
             }
             sql.append(selectString);
         }
 
+        // 执行SQL语句
         mHelper.getWritableDatabase().execSQL(sql.toString());
     }
 
+    /**
+     * 获取内容类型
+     * 
+     * @param uri 请求的URI
+     * @return 内容类型
+     */
     @Override
     public String getType(Uri uri) {
         // TODO Auto-generated method stub
         return null;
     }
-
 }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: MetaData.java
+ * 描述: Google Tasks元数据处理类，用于存储和管理便签与Google Tasks之间的映射关系
+ * 作用: 存储便签的元数据信息，建立本地便签与Google Tasks任务的关联
+ */
 package net.micode.notes.gtask.data;
 
 import android.database.Cursor;
@@ -24,37 +29,71 @@ import net.micode.notes.tool.GTaskStringUtils;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+/**
+ * MetaData类，继承自Task类
+ * 用于存储和管理Google Tasks与本地便签之间的映射关系
+ * 作为元数据存储容器，保存两端数据的关联信息
+ */
 public class MetaData extends Task {
+    /** 日志标签 */
     private final static String TAG = MetaData.class.getSimpleName();
 
+    /** 关联的Google Task ID */
     private String mRelatedGid = null;
 
+    /**
+     * 设置元数据信息
+     * 
+     * @param gid Google Task ID
+     * @param metaInfo 元数据信息的JSON对象
+     */
     public void setMeta(String gid, JSONObject metaInfo) {
         try {
+            // 将Google Task ID添加到元数据信息中
             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
         } catch (JSONException e) {
             Log.e(TAG, "failed to put related gid");
         }
+        // 将元数据JSON字符串设置为任务的备注
         setNotes(metaInfo.toString());
+        // 设置元数据任务的名称为固定值
         setName(GTaskStringUtils.META_NOTE_NAME);
     }
 
+    /**
+     * 获取关联的Google Task ID
+     * 
+     * @return 关联的Google Task ID
+     */
     public String getRelatedGid() {
         return mRelatedGid;
     }
 
+    /**
+     * 判断元数据是否值得保存
+     * 
+     * @return 如果备注不为空则返回true，否则返回false
+     */
     @Override
     public boolean isWorthSaving() {
         return getNotes() != null;
     }
 
+    /**
+     * 从远程JSON数据中设置内容
+     * 解析远程数据并提取关联的Google Task ID
+     * 
+     * @param js 远程JSON数据
+     */
     @Override
     public void setContentByRemoteJSON(JSONObject js) {
+        // 调用父类方法设置基本内容
         super.setContentByRemoteJSON(js);
         if (getNotes() != null) {
             try {
+                // 解析备注中的JSON数据
                 JSONObject metaInfo = new JSONObject(getNotes().trim());
+                // 获取关联的Google Task ID
                 mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
             } catch (JSONException e) {
                 Log.w(TAG, "failed to get related gid");
@@ -63,17 +102,39 @@ public class MetaData extends Task {
         }
     }
 
+    /**
+     * 从本地JSON数据中设置内容
+     * 此方法不应被调用，因为元数据只从远程获取
+     * 
+     * @param js 本地JSON数据
+     * @throws IllegalAccessError 如果调用此方法则抛出异常
+     */
     @Override
     public void setContentByLocalJSON(JSONObject js) {
-        // this function should not be called
+        // 此方法不应被调用
         throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
     }
 
+    /**
+     * 从内容中获取本地JSON数据
+     * 此方法不应被调用，因为元数据只从远程获取
+     * 
+     * @return JSONObject 本地JSON数据
+     * @throws IllegalAccessError 如果调用此方法则抛出异常
+     */
     @Override
     public JSONObject getLocalJSONFromContent() {
         throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
     }
 
+    /**
+     * 获取同步操作类型
+     * 此方法不应被调用，因为元数据的同步操作由GTaskManager管理
+     * 
+     * @param c 数据库游标
+     * @return 同步操作类型
+     * @throws IllegalAccessError 如果调用此方法则抛出异常
+     */
     @Override
     public int getSyncAction(Cursor c) {
         throw new IllegalAccessError("MetaData:getSyncAction should not be called");

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

@@ -14,39 +14,66 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: Node.java
+ * 描述: 数据节点抽象基类，定义了同步操作的基本接口和属性
+ * 作用: 为TaskList、Task和MetaData等具体类提供统一的接口和基本功能
+ */
 package net.micode.notes.gtask.data;
 
 import android.database.Cursor;
 
 import org.json.JSONObject;
 
+/**
+ * Node抽象类
+ * 定义了同步操作的基本接口和属性，是TaskList、Task和MetaData等类的基类
+ * 提供了数据同步过程中需要的基本操作和状态定义
+ */
 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;
 
+    /** Google Task ID */
     private String mGid;
 
+    /** 节点名称 */
     private String mName;
 
+    /** 最后修改时间 */
     private long mLastModified;
 
+    /** 是否已删除 */
     private boolean mDeleted;
 
+    /**
+     * 构造函数
+     * 初始化节点的基本属性
+     */
     public Node() {
         mGid = null;
         mName = "";
@@ -54,46 +81,119 @@ 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 Task ID
+     * 
+     * @param gid Google Task 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 Task ID
+     * 
+     * @return Google Task 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;
     }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: SqlData.java
+ * 描述: 便签数据内容的SQL操作封装类
+ * 作用: 管理便签内容数据的数据库操作，提供数据的CRUD功能
+ */
 package net.micode.notes.gtask.data;
 
 import android.content.ContentResolver;
@@ -34,43 +39,68 @@ import net.micode.notes.gtask.exception.ActionFailureException;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+/**
+ * SqlData类
+ * 负责管理便签内容数据的数据库操作
+ * 封装了对便签内容的增删改查功能
+ */
 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
     };
 
+    /** 数据ID列索引 */
     public static final int DATA_ID_COLUMN = 0;
 
+    /** 数据MIME类型列索引 */
     public static final int DATA_MIME_TYPE_COLUMN = 1;
 
+    /** 数据内容列索引 */
     public static final int DATA_CONTENT_COLUMN = 2;
 
+    /** 数据DATA1列索引 */
     public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
 
+    /** 数据DATA3列索引 */
     public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
 
+    /** 内容解析器 */
     private ContentResolver mContentResolver;
 
+    /** 是否为新建数据标志 */
     private boolean mIsCreate;
 
+    /** 数据ID */
     private long mDataId;
 
+    /** 数据MIME类型 */
     private String mDataMimeType;
 
+    /** 数据内容 */
     private String mDataContent;
 
+    /** 数据DATA1值 */
     private long mDataContentData1;
 
+    /** 数据DATA3值 */
     private String mDataContentData3;
 
+    /** 数据变更值集合 */
     private ContentValues mDiffDataValues;
 
+    /**
+     * 构造函数 - 创建新的数据对象
+     * 
+     * @param context 应用上下文
+     */
     public SqlData(Context context) {
         mContentResolver = context.getContentResolver();
         mIsCreate = true;
@@ -82,6 +112,12 @@ public class SqlData {
         mDiffDataValues = new ContentValues();
     }
 
+    /**
+     * 构造函数 - 从数据库游标加载现有数据
+     * 
+     * @param context 应用上下文
+     * @param c 数据库游标
+     */
     public SqlData(Context context, Cursor c) {
         mContentResolver = context.getContentResolver();
         mIsCreate = false;
@@ -89,6 +125,11 @@ 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,13 +138,22 @@ 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 {
+        // 处理数据ID
         long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
         if (mIsCreate || mDataId != dataId) {
             mDiffDataValues.put(DataColumns.ID, dataId);
         }
         mDataId = dataId;
 
+        // 处理MIME类型
         String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
                 : DataConstants.NOTE;
         if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
@@ -111,18 +161,21 @@ public class SqlData {
         }
         mDataMimeType = dataMimeType;
 
+        // 处理内容
         String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
         if (mIsCreate || !mDataContent.equals(dataContent)) {
             mDiffDataValues.put(DataColumns.CONTENT, dataContent);
         }
         mDataContent = dataContent;
 
+        // 处理DATA1
         long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
         if (mIsCreate || mDataContentData1 != dataContentData1) {
             mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
         }
         mDataContentData1 = dataContentData1;
 
+        // 处理DATA3
         String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
         if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
             mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
@@ -130,6 +183,12 @@ 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,13 +203,22 @@ public class SqlData {
         return js;
     }
 
+    /**
+     * 提交数据变更到数据库
+     * 
+     * @param noteId 关联的便签ID
+     * @param validateVersion 是否验证版本
+     * @param version 版本号
+     */
     public void commit(long noteId, boolean validateVersion, long version) {
-
+        // 新建数据
         if (mIsCreate) {
+            // 处理无效ID
             if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
                 mDiffDataValues.remove(DataColumns.ID);
             }
 
+            // 设置关联的便签ID
             mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
             Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
             try {
@@ -160,12 +228,15 @@ public class SqlData {
                 throw new ActionFailureException("create note failed");
             }
         } else {
+            // 更新现有数据
             if (mDiffDataValues.size() > 0) {
                 int result = 0;
                 if (!validateVersion) {
+                    // 不验证版本的更新
                     result = mContentResolver.update(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
                 } else {
+                    // 验证版本的更新
                     result = mContentResolver.update(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
                             " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
@@ -179,10 +250,16 @@ public class SqlData {
             }
         }
 
+        // 清空变更记录并更新状态
         mDiffDataValues.clear();
         mIsCreate = false;
     }
 
+    /**
+     * 获取数据ID
+     * 
+     * @return 数据ID
+     */
     public long getId() {
         return mDataId;
     }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: SqlNote.java
+ * 描述: 便签数据的SQL操作封装类
+ * 作用: 管理便签数据的数据库操作，提供便签的CRUD功能，是应用与数据库交互的核心类
+ */
 package net.micode.notes.gtask.data;
 
 import android.appwidget.AppWidgetManager;
@@ -37,12 +42,19 @@ import org.json.JSONObject;
 
 import java.util.ArrayList;
 
-
+/**
+ * SqlNote类
+ * 负责管理便签数据的数据库操作
+ * 封装了对便签的增删改查功能，并处理与Google Tasks的数据同步
+ */
 public class SqlNote {
+    /** 日志标签 */
     private static final String TAG = SqlNote.class.getSimpleName();
 
+    /** 无效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 +64,116 @@ public class SqlNote {
             NoteColumns.VERSION
     };
 
+    /** ID列索引 */
     public static final int ID_COLUMN = 0;
 
+    /** 提醒日期列索引 */
     public static final int ALERTED_DATE_COLUMN = 1;
 
+    /** 背景颜色ID列索引 */
     public static final int BG_COLOR_ID_COLUMN = 2;
 
+    /** 创建日期列索引 */
     public static final int CREATED_DATE_COLUMN = 3;
 
+    /** 是否有附件列索引 */
     public static final int HAS_ATTACHMENT_COLUMN = 4;
 
+    /** 修改日期列索引 */
     public static final int MODIFIED_DATE_COLUMN = 5;
 
+    /** 便签数量列索引 */
     public static final int NOTES_COUNT_COLUMN = 6;
 
+    /** 父ID列索引 */
     public static final int PARENT_ID_COLUMN = 7;
 
+    /** 摘要列索引 */
     public static final int SNIPPET_COLUMN = 8;
 
+    /** 类型列索引 */
     public static final int TYPE_COLUMN = 9;
 
+    /** 小部件ID列索引 */
     public static final int WIDGET_ID_COLUMN = 10;
 
+    /** 小部件类型列索引 */
     public static final int WIDGET_TYPE_COLUMN = 11;
 
+    /** 同步ID列索引 */
     public static final int SYNC_ID_COLUMN = 12;
 
+    /** 本地修改标志列索引 */
     public static final int LOCAL_MODIFIED_COLUMN = 13;
 
+    /** 原始父ID列索引 */
     public static final int ORIGIN_PARENT_ID_COLUMN = 14;
 
+    /** Google Task ID列索引 */
     public static final int GTASK_ID_COLUMN = 15;
 
+    /** 版本列索引 */
     public static final int VERSION_COLUMN = 16;
 
+    /** 应用上下文 */
     private Context mContext;
 
+    /** 内容解析器 */
     private ContentResolver mContentResolver;
 
+    /** 是否为新建便签标志 */
     private boolean mIsCreate;
 
+    /** 便签ID */
     private long mId;
 
+    /** 提醒日期 */
     private long mAlertDate;
 
+    /** 背景颜色ID */
     private int mBgColorId;
 
+    /** 创建日期 */
     private long mCreatedDate;
 
+    /** 是否有附件 */
     private int mHasAttachment;
 
+    /** 修改日期 */
     private long mModifiedDate;
 
+    /** 父ID */
     private long mParentId;
 
+    /** 摘要 */
     private String mSnippet;
 
+    /** 类型 */
     private int mType;
 
+    /** 小部件ID */
     private int mWidgetId;
 
+    /** 小部件类型 */
     private int mWidgetType;
 
+    /** 原始父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 +195,12 @@ public class SqlNote {
         mDataList = new ArrayList<SqlData>();
     }
 
+    /**
+     * 构造函数 - 从数据库游标加载现有便签
+     * 
+     * @param context 应用上下文
+     * @param c 数据库游标
+     */
     public SqlNote(Context context, Cursor c) {
         mContext = context;
         mContentResolver = context.getContentResolver();
@@ -154,6 +212,12 @@ 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 +227,13 @@ 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 +253,11 @@ public class SqlNote {
         }
     }
 
+    /**
+     * 从数据库游标加载便签数据
+     * 
+     * @param c 数据库游标
+     */
     private void loadFromCursor(Cursor c) {
         mId = c.getLong(ID_COLUMN);
         mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@@ -200,10 +273,15 @@ public class SqlNote {
         mVersion = c.getLong(VERSION_COLUMN);
     }
 
+    /**
+     * 加载便签的内容数据
+     * 从数据库中查询与当前便签关联的所有数据项
+     */
     private void loadDataContent() {
         Cursor c = null;
         mDataList.clear();
         try {
+            // 查询与当前便签ID关联的所有数据
             c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
                     "(note_id=?)", new String[] {
                         String.valueOf(mId)
@@ -213,6 +291,7 @@ public class SqlNote {
                     Log.w(TAG, "it seems that the note has not data");
                     return;
                 }
+                // 遍历所有数据项并添加到数据列表中
                 while (c.moveToNext()) {
                     SqlData data = new SqlData(mContext, c);
                     mDataList.add(data);
@@ -226,13 +305,22 @@ public class SqlNote {
         }
     }
 
+    /**
+     * 从JSON对象设置便签内容
+     * 解析JSON数据并更新便签的各个属性
+     * 
+     * @param js JSON对象，包含便签数据
+     * @return 设置是否成功
+     */
     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 +335,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 +420,11 @@ public class SqlNote {
                 }
                 mOriginParent = originParent;
 
+                // 处理便签的数据内容
                 for (int i = 0; i < dataArray.length(); i++) {
                     JSONObject data = dataArray.getJSONObject(i);
                     SqlData sqlData = null;
+                    // 查找是否存在匹配的数据项
                     if (data.has(DataColumns.ID)) {
                         long dataId = data.getLong(DataColumns.ID);
                         for (SqlData temp : mDataList) {
@@ -343,11 +434,13 @@ public class SqlNote {
                         }
                     }
 
+                    // 如果没有找到匹配的数据项，则创建新的
                     if (sqlData == null) {
                         sqlData = new SqlData(mContext);
                         mDataList.add(sqlData);
                     }
 
+                    // 设置数据内容
                     sqlData.setContent(data);
                 }
             }
@@ -359,6 +452,12 @@ public class SqlNote {
         return true;
     }
 
+    /**
+     * 获取便签内容的JSON对象表示
+     * 将便签的属性和数据内容转换为JSON格式
+     * 
+     * @return 包含便签内容的JSON对象
+     */
     public JSONObject getContent() {
         try {
             JSONObject js = new JSONObject();
@@ -370,6 +469,7 @@ public class SqlNote {
 
             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 +484,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 +494,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,45 +509,92 @@ public class SqlNote {
         return null;
     }
 
+    /**
+     * 设置便签的父ID
+     * 
+     * @param id 父便签的ID
+     */
     public void setParentId(long id) {
         mParentId = id;
         mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
     }
 
+    /**
+     * 设置便签的Google Task ID
+     * 
+     * @param gid Google Task 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);
     }
 
+    /**
+     * 重置本地修改标志
+     * 表示便签已经同步到服务器
+     */
     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) {
+            // 处理新建便签
             if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
                 mDiffNoteValues.remove(NoteColumns.ID);
             }
 
+            // 插入新便签到数据库
             Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
             try {
                 mId = Long.valueOf(uri.getPathSegments().get(1));
@@ -457,25 +606,30 @@ 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 {
+            // 处理更新便签
             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 ++;
                 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 +641,7 @@ public class SqlNote {
                 }
             }
 
+            // 提交便签关联的数据内容
             if (mType == Notes.TYPE_NOTE) {
                 for (SqlData sqlData : mDataList) {
                     sqlData.commit(mId, validateVersion, mVersion);
@@ -494,11 +649,12 @@ public class SqlNote {
             }
         }
 
-        // refresh local info
+        // 刷新本地信息
         loadFromCursor(mId);
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
 
+        // 清空变更记录并更新状态
         mDiffNoteValues.clear();
         mIsCreate = false;
     }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: Task.java
+ * 描述: Google Tasks任务数据模型类，表示单个任务项
+ * 作用: 提供Google Tasks任务的数据结构和操作方法，是Google Tasks同步功能的核心数据模型之一
+ */
 package net.micode.notes.gtask.data;
 
 import android.database.Cursor;
@@ -31,20 +36,34 @@ import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+/**
+ * Google Tasks任务数据模型类
+ * 
+ * 继承自Node类，表示Google Tasks中的单个任务项
+ * 负责任务数据的存储、转换和同步操作
+ */
 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;
@@ -54,6 +73,13 @@ public class Task extends Node {
         mMetaInfo = null;
     }
 
+    /**
+     * 生成创建任务的JSON操作对象
+     * 
+     * @param actionId 操作ID
+     * @return 创建任务的JSON操作对象
+     * @throws ActionFailureException 如果生成JSON对象失败
+     */
     public JSONObject getCreateAction(int actionId) {
         JSONObject js = new JSONObject();
 
@@ -103,6 +129,13 @@ public class Task extends Node {
         return js;
     }
 
+    /**
+     * 生成更新任务的JSON操作对象
+     * 
+     * @param actionId 操作ID
+     * @return 更新任务的JSON操作对象
+     * @throws ActionFailureException 如果生成JSON对象失败
+     */
     public JSONObject getUpdateAction(int actionId) {
         JSONObject js = new JSONObject();
 
@@ -135,6 +168,12 @@ public class Task extends Node {
         return js;
     }
 
+    /**
+     * 根据远程JSON数据设置任务内容
+     * 
+     * @param js 远程JSON数据对象
+     * @throws ActionFailureException 如果解析JSON对象失败
+     */
     public void setContentByRemoteJSON(JSONObject js) {
         if (js != null) {
             try {
@@ -175,6 +214,11 @@ 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)) {
@@ -182,14 +226,17 @@ public class Task extends Node {
         }
 
         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,16 +251,22 @@ public class Task extends Node {
         }
     }
 
+    /**
+     * 从任务内容生成本地JSON数据
+     * 
+     * @return 本地JSON数据对象，如果生成失败则返回null
+     */
     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();
@@ -225,10 +278,11 @@ public class Task extends Node {
                 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)) {
@@ -247,6 +301,11 @@ public class Task extends Node {
         }
     }
 
+    /**
+     * 设置任务元数据信息
+     * 
+     * @param metaData 元数据对象
+     */
     public void setMetaInfo(MetaData metaData) {
         if (metaData != null && metaData.getNotes() != null) {
             try {
@@ -258,8 +317,15 @@ public class Task extends Node {
         }
     }
 
+    /**
+     * 获取任务的同步操作类型
+     * 
+     * @param c 便签数据游标
+     * @return 同步操作类型
+     */
     public int getSyncAction(Cursor c) {
         try {
+            // 获取便签元数据信息
             JSONObject noteInfo = null;
             if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
                 noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
@@ -275,31 +341,32 @@ public class Task extends Node {
                 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,41 +378,85 @@ 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;
     }
-
 }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: TaskList.java
+ * 描述: 任务列表数据模型，对应Google Tasks中的任务列表
+ * 作用: 管理任务列表及其包含的任务，处理任务列表的创建、更新、同步等操作
+ */
 package net.micode.notes.gtask.data;
 
 import android.database.Cursor;
@@ -29,35 +34,56 @@ import org.json.JSONObject;
 
 import java.util.ArrayList;
 
-
+/**
+ * 任务列表类
+ * 
+ * 该类表示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;
     }
 
+    /**
+     * 生成创建任务列表的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");
@@ -74,21 +100,27 @@ 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());
@@ -103,20 +135,25 @@ 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,6 +166,11 @@ 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");
@@ -137,6 +179,7 @@ public class TaskList extends Node {
         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);
@@ -157,11 +200,17 @@ 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(),
@@ -183,28 +232,35 @@ public class TaskList extends Node {
         }
     }
 
+    /**
+     * 获取同步操作类型
+     * 根据本地和远程数据的状态确定同步操作类型
+     * 
+     * @param c 本地数据游标
+     * @return 同步操作类型
+     */
     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任务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 +272,27 @@ public class TaskList extends Node {
         return SYNC_ACTION_ERROR;
     }
 
+    /**
+     * 获取子任务数量
+     * 
+     * @return 子任务数量
+     */
     public int getChildTaskCount() {
         return mChildren.size();
     }
 
+    /**
+     * 添加子任务到任务列表末尾
+     * 
+     * @param task 要添加的任务
+     * @return 添加是否成功
+     */
     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 +301,13 @@ public class TaskList extends Node {
         return ret;
     }
 
+    /**
+     * 在指定位置添加子任务
+     * 
+     * @param task 要添加的任务
+     * @param index 添加位置
+     * @return 添加是否成功
+     */
     public boolean addChildTask(Task task, int index) {
         if (index < 0 || index > mChildren.size()) {
             Log.e(TAG, "add child task: invalid index");
@@ -244,7 +318,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 +334,12 @@ public class TaskList extends Node {
         return true;
     }
 
+    /**
+     * 从任务列表中移除子任务
+     * 
+     * @param task 要移除的任务
+     * @return 移除是否成功
+     */
     public boolean removeChildTask(Task task) {
         boolean ret = false;
         int index = mChildren.indexOf(task);
@@ -267,11 +347,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,6 +361,13 @@ public class TaskList extends Node {
         return ret;
     }
 
+    /**
+     * 移动子任务到指定位置
+     * 
+     * @param task 要移动的任务
+     * @param index 目标位置
+     * @return 移动是否成功
+     */
     public boolean moveChildTask(Task task, int index) {
 
         if (index < 0 || index >= mChildren.size()) {
@@ -299,6 +386,12 @@ public class TaskList extends Node {
         return (removeChildTask(task) && addChildTask(task, index));
     }
 
+    /**
+     * 根据Google任务ID查找子任务
+     * 
+     * @param gid Google任务ID
+     * @return 找到的任务，未找到返回null
+     */
     public Task findChildTaskByGid(String gid) {
         for (int i = 0; i < mChildren.size(); i++) {
             Task t = mChildren.get(i);
@@ -309,10 +402,22 @@ public class TaskList extends Node {
         return null;
     }
 
+    /**
+     * 获取子任务在列表中的索引
+     * 
+     * @param task 子任务
+     * @return 任务索引，不存在返回-1
+     */
     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 +426,12 @@ public class TaskList extends Node {
         return mChildren.get(index);
     }
 
+    /**
+     * 根据Google任务ID获取子任务
+     * 
+     * @param gid Google任务ID
+     * @return 子任务，未找到返回null
+     */
     public Task getChilTaskByGid(String gid) {
         for (Task task : mChildren) {
             if (task.getGid().equals(gid))
@@ -329,14 +440,29 @@ 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;
     }

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

@@ -14,19 +14,46 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: ActionFailureException.java
+ * 描述: 操作失败异常类，用于处理Google Tasks同步过程中的操作失败情况
+ * 作用: 提供一个专门的异常类型，用于标识和处理Google Tasks同步操作中的各种失败情况
+ */
 package net.micode.notes.gtask.exception;
 
+/**
+ * 操作失败异常类
+ * 
+ * 继承自RuntimeException，表示在Google Tasks同步过程中发生的操作失败
+ * 这是一个运行时异常，不需要强制捕获，通常用于表示程序逻辑错误或不可恢复的错误
+ */
 public class ActionFailureException extends RuntimeException {
+    /** 序列化版本ID */
     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);
     }

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

@@ -14,19 +14,46 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NetworkFailureException.java
+ * 描述: 网络失败异常类，用于处理Google Tasks同步过程中的网络错误
+ * 作用: 提供一个专门的异常类型，用于标识和处理Google Tasks同步过程中的网络连接问题
+ */
 package net.micode.notes.gtask.exception;
 
+/**
+ * 网络失败异常类
+ * 
+ * 继承自Exception，表示在Google Tasks同步过程中发生的网络连接失败
+ * 这是一个检查型异常，需要显式捕获或声明抛出，通常用于表示可能恢复的错误情况
+ */
 public class NetworkFailureException extends Exception {
+    /** 序列化版本ID */
     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);
     }

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

@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
  *
@@ -15,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: GTaskASyncTask.java
+ * 描述: Google Tasks异步任务类，负责在后台线程执行同步操作
+ * 作用: 提供异步同步功能，避免在UI线程执行耗时的网络和同步操作，并显示同步进度通知
+ */
 package net.micode.notes.gtask.remote;
 
 import android.app.Notification;
@@ -28,23 +32,52 @@ import net.micode.notes.R;
 import net.micode.notes.ui.NotesListActivity;
 import net.micode.notes.ui.NotesPreferenceActivity;
 
-
+/**
+ * Google Tasks异步任务类
+ * 
+ * 该类继承自AsyncTask，用于在后台线程执行Google Tasks同步操作，
+ * 避免阻塞UI线程，并通过通知栏显示同步进度和结果。
+ * 
+ * 主要功能：
+ * 1. 在后台线程执行同步操作
+ * 2. 显示同步进度通知
+ * 3. 处理同步结果和错误
+ * 4. 支持取消同步操作
+ */
 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
 
+    /** 同步通知的唯一ID */
     private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
 
+    /**
+     * 同步完成监听器接口
+     * 用于通知调用者同步操作已完成
+     */
     public interface OnCompleteListener {
+        /**
+         * 当同步操作完成时调用
+         */
         void onComplete();
     }
 
+    /** 应用上下文 */
     private Context mContext;
 
+    /** 通知管理器 */
     private NotificationManager mNotifiManager;
 
+    /** Google Tasks同步管理器 */
     private GTaskManager mTaskManager;
 
+    /** 同步完成监听器 */
     private OnCompleteListener mOnCompleteListener;
 
+    /**
+     * 构造函数
+     * 
+     * @param context 应用上下文
+     * @param listener 同步完成监听器
+     */
     public GTaskASyncTask(Context context, OnCompleteListener listener) {
         mContext = context;
         mOnCompleteListener = listener;
@@ -53,16 +86,31 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         mTaskManager = GTaskManager.getInstance();
     }
 
+    /**
+     * 取消同步操作
+     * 通知GTaskManager取消正在进行的同步
+     */
     public void cancelSync() {
         mTaskManager.cancelSync();
     }
 
+    /**
+     * 发布同步进度
+     * 
+     * @param message 进度消息
+     */
     public void publishProgess(String message) {
         publishProgress(new String[] {
             message
         });
     }
 
+    /**
+     * 显示同步通知
+     * 
+     * @param tickerId 通知标题资源ID
+     * @param content 通知内容
+     */
     private void showNotification(int tickerId, String content) {
         PendingIntent pendingIntent;
         if (tickerId != R.string.ticker_success) {
@@ -74,7 +122,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
                     NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE);
         }
 
-        // Use modern notification builder (API 21+ support)
+        // 使用现代通知构建器（支持API 21+）
         Notification notification = new Notification.Builder(mContext)
                 .setContentTitle(mContext.getString(R.string.app_name))
                 .setContentText(content)
@@ -87,6 +135,12 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
     }
 
+    /**
+     * 在后台线程执行同步操作
+     * 
+     * @param unused 未使用的参数
+     * @return 同步结果状态码
+     */
     @Override
     protected Integer doInBackground(Void... unused) {
         publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
@@ -94,6 +148,12 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         return mTaskManager.sync(mContext, this);
     }
 
+    /**
+     * 更新同步进度
+     * 在UI线程中显示同步进度通知
+     * 
+     * @param progress 进度信息
+     */
     @Override
     protected void onProgressUpdate(String... progress) {
         showNotification(R.string.ticker_syncing, progress[0]);
@@ -102,6 +162,12 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         }
     }
 
+    /**
+     * 处理同步完成事件
+     * 根据同步结果显示相应通知，并调用完成监听器
+     * 
+     * @param result 同步结果状态码
+     */
     @Override
     protected void onPostExecute(Integer result) {
         if (result == GTaskManager.STATE_SUCCESS) {

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: GTaskClient.java
+ * 描述: Google Tasks客户端，负责与Google Tasks API进行通信
+ * 作用: 提供与Google Tasks服务器交互的接口，包括登录认证、数据请求和操作提交等功能
+ */
 package net.micode.notes.gtask.remote;
 
 import android.accounts.Account;
@@ -60,36 +65,65 @@ import java.util.zip.GZIPInputStream;
 import java.util.zip.Inflater;
 import java.util.zip.InflaterInputStream;
 
-
+/**
+ * Google Tasks客户端类
+ * 
+ * 该类负责与Google Tasks API进行通信，提供登录认证、数据请求和操作提交等功能。
+ * 使用单例模式确保全局只有一个客户端实例，管理与Google Tasks服务器的连接和会话。
+ * 
+ * 主要功能包括：
+ * 1. Google账户认证和登录
+ * 2. 获取任务列表和任务数据
+ * 3. 创建、更新和删除任务及任务列表
+ * 4. 处理HTTP请求和响应
+ */
 public class GTaskClient {
+    /** 日志标签 */
     private static final String TAG = GTaskClient.class.getSimpleName();
 
+    /** Google Tasks基础URL */
     private static final String GTASK_URL = "https://mail.google.com/tasks/";
 
+    /** Google Tasks GET请求URL */
     private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
 
+    /** Google Tasks POST请求URL */
     private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
 
+    /** 单例实例 */
     private static GTaskClient mInstance = null;
 
+    /** HTTP客户端 */
     private DefaultHttpClient mHttpClient;
 
+    /** GET请求URL */
     private String mGetUrl;
 
+    /** POST请求URL */
     private String mPostUrl;
 
+    /** 客户端版本号 */
     private long mClientVersion;
 
+    /** 登录状态标志 */
     private boolean mLoggedin;
 
+    /** 最后登录时间 */
     private long mLastLoginTime;
 
+    /** 操作ID计数器 */
     private int mActionId;
 
+    /** Google账户 */
     private Account mAccount;
 
+    /** 更新操作数组 */
     private JSONArray mUpdateArray;
 
+    /**
+     * 私有构造函数，初始化Google Tasks客户端
+     * 遵循单例模式，只能通过getInstance方法获取实例
+     */
     private GTaskClient() {
         mHttpClient = null;
         mGetUrl = GTASK_GET_URL;
@@ -102,6 +136,11 @@ public class GTaskClient {
         mUpdateArray = null;
     }
 
+    /**
+     * 获取GTaskClient的单例实例
+     * 
+     * @return GTaskClient的单例实例
+     */
     public static synchronized GTaskClient getInstance() {
         if (mInstance == null) {
             mInstance = new GTaskClient();
@@ -109,26 +148,33 @@ public class GTaskClient {
         return mInstance;
     }
 
+    /**
+     * 登录Google Tasks服务
+     * 
+     * @param activity 用于获取账户授权的活动
+     * @return 登录是否成功
+     */
     public boolean login(Activity activity) {
-        // we suppose that the cookie would expire after 5 minutes
+        // 检查登录会话是否过期（5分钟）
-        // then we need to re-login
         final long interval = 1000 * 60 * 5;
         if (mLastLoginTime + interval < System.currentTimeMillis()) {
             mLoggedin = false;
         }
 
-        // need to re-login after account switch
+        // 切换账户后需要重新登录
         if (mLoggedin
                 && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
                         .getSyncAccountName(activity))) {
             mLoggedin = false;
         }
 
+        // 如果已登录，直接返回
         if (mLoggedin) {
             Log.d(TAG, "already logged in");
             return true;
         }
 
+        // 更新最后登录时间并获取授权令牌
         mLastLoginTime = System.currentTimeMillis();
         String authToken = loginGoogleAccount(activity, false);
         if (authToken == null) {
@@ -136,7 +182,7 @@ public class GTaskClient {
             return false;
         }
 
-        // login with custom domain if necessary
+        // 如果是自定义域名账户，需要特殊处理
         if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
                 .endsWith("googlemail.com"))) {
             StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
@@ -151,7 +197,7 @@ public class GTaskClient {
             }
         }
 
-        // try to login with google official url
+        // 尝试使用官方URL登录
         if (!mLoggedin) {
             mGetUrl = GTASK_GET_URL;
             mPostUrl = GTASK_POST_URL;
@@ -164,16 +210,25 @@ public class GTaskClient {
         return true;
     }
 
+    /**
+     * 登录Google账户并获取授权令牌
+     * 
+     * @param activity 用于获取账户授权的活动
+     * @param invalidateToken 是否使当前令牌失效并重新获取
+     * @return 授权令牌，失败返回null
+     */
     private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
         String authToken;
         AccountManager accountManager = AccountManager.get(activity);
         Account[] accounts = accountManager.getAccountsByType("com.google");
 
+        // 检查是否有可用的Google账户
         if (accounts.length == 0) {
             Log.e(TAG, "there is no available google account");
             return null;
         }
 
+        // 根据设置中的账户名找到对应账户
         String accountName = NotesPreferenceActivity.getSyncAccountName(activity);
         Account account = null;
         for (Account a : accounts) {
@@ -189,13 +244,14 @@ public class GTaskClient {
             return null;
         }
 
-        // get the token now
+        // 获取授权令牌
         AccountManagerFuture<Bundle> accountManagerFuture = accountManager.getAuthToken(account,
                 "goanna_mobile", null, activity, null, null);
         try {
             Bundle authTokenBundle = accountManagerFuture.getResult();
             authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN);
             if (invalidateToken) {
+                // 使令牌失效并重新获取
                 accountManager.invalidateAuthToken("com.google", authToken);
                 loginGoogleAccount(activity, false);
             }
@@ -207,10 +263,16 @@ public class GTaskClient {
         return authToken;
     }
 
+    /**
+     * 尝试登录Google Tasks服务
+     * 
+     * @param 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
+            // 如果令牌过期，使其失效并重新尝试
-            // token and try again
             authToken = loginGoogleAccount(activity, true);
             if (authToken == null) {
                 Log.e(TAG, "login google account failed");
@@ -225,7 +287,14 @@ public class GTaskClient {
         return true;
     }
 
+    /**
+     * 使用授权令牌登录Google Tasks服务
+     * 
+     * @param authToken 授权令牌
+     * @return 登录是否成功
+     */
     private boolean loginGtask(String authToken) {
+        // 设置HTTP连接参数
         int timeoutConnection = 10000;
         int timeoutSocket = 15000;
         HttpParams httpParameters = new BasicHttpParams();
@@ -236,14 +305,14 @@ public class GTaskClient {
         mHttpClient.setCookieStore(localBasicCookieStore);
         HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
 
-        // login gtask
+        // 登录Google Tasks
         try {
             String loginUrl = mGetUrl + "?auth=" + authToken;
             HttpGet httpGet = new HttpGet(loginUrl);
             HttpResponse response = null;
             response = mHttpClient.execute(httpGet);
 
-            // get the cookie now
+            // 获取认证Cookie
             List<Cookie> cookies = mHttpClient.getCookieStore().getCookies();
             boolean hasAuthCookie = false;
             for (Cookie cookie : cookies) {
@@ -255,7 +324,7 @@ public class GTaskClient {
                 Log.w(TAG, "it seems that there is no auth cookie");
             }
 
-            // get the client version
+            // 获取客户端版本号
             String resString = getResponseContent(response.getEntity());
             String jsBegin = "_setup(";
             String jsEnd = ")}</script>";
@@ -272,7 +341,7 @@ public class GTaskClient {
             e.printStackTrace();
             return false;
         } catch (Exception e) {
-            // simply catch all exceptions
+            // 捕获所有异常
             Log.e(TAG, "httpget gtask_url failed");
             return false;
         }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: GTaskManager.java
+ * 描述: Google Tasks同步管理器，负责协调本地便签与Google Tasks之间的数据同步
+ * 作用: 管理同步过程中的数据映射、冲突解决和同步状态，是应用与Google Tasks服务交互的核心组件
+ */
 package net.micode.notes.gtask.remote;
 
 import android.app.Activity;
@@ -47,46 +52,80 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
 
-
+/**
+ * Google Tasks同步管理器类
+ * 
+ * 该类负责管理本地便签与Google Tasks之间的数据同步，包括登录认证、数据获取、
+ * 内容同步、冲突解决等功能。采用单例模式确保全局只有一个同步管理器实例。
+ * 
+ * 同步过程包括以下主要步骤：
+ * 1. 登录Google账户并获取授权
+ * 2. 获取远程任务列表
+ * 3. 同步本地和远程数据
+ * 4. 处理冲突和更新
+ */
 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;
 
+    /** Google任务列表映射表 <任务列表ID, TaskList对象> */
     private HashMap<String, TaskList> mGTaskListHashMap;
 
+    /** Google任务节点映射表 <节点ID, Node对象> */
     private HashMap<String, Node> mGTaskHashMap;
 
+    /** 元数据映射表 <关联ID, 元数据对象> */
     private HashMap<String, MetaData> mMetaHashMap;
 
+    /** 元数据任务列表 */
     private TaskList mMetaList;
 
+    /** 本地已删除ID集合 */
     private HashSet<Long> mLocalDeleteIdMap;
 
+    /** Google ID到本地笔记ID的映射 */
     private HashMap<String, Long> mGidToNid;
 
+    /** 本地笔记ID到Google ID的映射 */
     private HashMap<Long, String> mNidToGid;
 
+    /**
+     * 私有构造函数，初始化同步管理器
+     * 遵循单例模式，只能通过getInstance方法获取实例
+     */
     private GTaskManager() {
         mSyncing = false;
         mCancelled = false;
@@ -99,6 +138,11 @@ public class GTaskManager {
         mNidToGid = new HashMap<Long, String>();
     }
 
+    /**
+     * 获取GTaskManager的单例实例
+     * 
+     * @return GTaskManager的单例实例
+     */
     public static synchronized GTaskManager getInstance() {
         if (mInstance == null) {
             mInstance = new GTaskManager();
@@ -106,16 +150,32 @@ public class GTaskManager {
         return mInstance;
     }
 
+    /**
+     * 设置活动上下文
+     * 用于获取Google账户授权令牌
+     * 
+     * @param activity 活动上下文
+     */
     public synchronized void setActivityContext(Activity activity) {
         // used for getting authtoken
         mActivity = activity;
     }
 
+    /**
+     * 执行同步操作
+     * 
+     * @param context 应用上下文
+     * @param asyncTask 异步任务对象，用于发布进度更新
+     * @return 同步状态码
+     */
     public int sync(Context context, GTaskASyncTask asyncTask) {
+        // 检查是否已有同步进行中
         if (mSyncing) {
             Log.d(TAG, "Sync is in progress");
             return STATE_SYNC_IN_PROGRESS;
         }
+        
+        // 初始化同步环境
         mContext = context;
         mContentResolver = mContext.getContentResolver();
         mSyncing = true;
@@ -128,34 +188,39 @@ public class GTaskManager {
         mNidToGid.clear();
 
         try {
+            // 获取GTaskClient实例并重置更新数组
             GTaskClient client = GTaskClient.getInstance();
             client.resetUpdateArray();
 
-            // login google task
+            // 登录Google Tasks服务
             if (!mCancelled) {
                 if (!client.login(mActivity)) {
                     throw new NetworkFailureException("login google task failed");
                 }
             }
 
-            // get the task list from google
+            // 获取远程任务列表
             asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
             initGTaskList();
 
-            // do content sync work
+            // 执行内容同步
             asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
             syncContent();
         } catch (NetworkFailureException e) {
+            // 处理网络错误
             Log.e(TAG, e.toString());
             return STATE_NETWORK_ERROR;
         } catch (ActionFailureException e) {
+            // 处理内部错误
             Log.e(TAG, e.toString());
             return STATE_INTERNAL_ERROR;
         } catch (Exception e) {
+            // 处理其他异常
             Log.e(TAG, e.toString());
             e.printStackTrace();
             return STATE_INTERNAL_ERROR;
         } finally {
+            // 清理资源
             mGTaskListHashMap.clear();
             mGTaskHashMap.clear();
             mMetaHashMap.clear();
@@ -165,29 +230,40 @@ public class GTaskManager {
             mSyncing = false;
         }
 
+        // 返回同步结果
         return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
     }
 
+    /**
+     * 初始化Google任务列表
+     * 从远程服务器获取任务列表和任务数据，并构建本地数据结构
+     * 
+     * @throws NetworkFailureException 网络连接失败时抛出
+     */
     private void initGTaskList() throws NetworkFailureException {
+        // 检查是否已取消同步
         if (mCancelled)
             return;
+            
         GTaskClient client = GTaskClient.getInstance();
         try {
+            // 获取所有任务列表
             JSONArray jsTaskLists = client.getTaskLists();
 
-            // init meta list first
+            // 首先初始化元数据列表
             mMetaList = null;
             for (int i = 0; i < jsTaskLists.length(); i++) {
                 JSONObject object = jsTaskLists.getJSONObject(i);
                 String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
                 String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
 
+                // 查找元数据列表
                 if (name
                         .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
                     mMetaList = new TaskList();
                     mMetaList.setContentByRemoteJSON(object);
 
-                    // load meta data
+                    // 加载元数据
                     JSONArray jsMetas = client.getTaskList(gid);
                     for (int j = 0; j < jsMetas.length(); j++) {
                         object = (JSONObject) jsMetas.getJSONObject(j);
@@ -203,7 +279,7 @@ public class GTaskManager {
                 }
             }
 
-            // create meta list if not existed
+            // 如果元数据列表不存在，则创建一个
             if (mMetaList == null) {
                 mMetaList = new TaskList();
                 mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
@@ -211,12 +287,13 @@ public class GTaskManager {
                 GTaskClient.getInstance().createTaskList(mMetaList);
             }
 
-            // init task list
+            // 初始化任务列表
             for (int i = 0; i < jsTaskLists.length(); i++) {
                 JSONObject object = jsTaskLists.getJSONObject(i);
                 String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
                 String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
 
+                // 处理MIUI文件夹前缀的任务列表（排除元数据列表）
                 if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)
                         && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
                                 + GTaskStringUtils.FOLDER_META)) {
@@ -225,7 +302,7 @@ public class GTaskManager {
                     mGTaskListHashMap.put(gid, tasklist);
                     mGTaskHashMap.put(gid, tasklist);
 
-                    // load tasks
+                    // 加载任务
                     JSONArray jsTasks = client.getTaskList(gid);
                     for (int j = 0; j < jsTasks.length(); j++) {
                         object = (JSONObject) jsTasks.getJSONObject(j);
@@ -241,6 +318,7 @@ public class GTaskManager {
                 }
             }
         } catch (JSONException e) {
+            // 处理JSON解析异常
             Log.e(TAG, e.toString());
             e.printStackTrace();
             throw new ActionFailureException("initGTaskList: handing JSONObject failed");

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

@@ -14,6 +14,12 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: GTaskSyncService.java
+ * 描述: Google Tasks同步服务，负责处理便签与Google Tasks的同步操作
+ * 作用: 提供便签与Google Tasks的同步功能，包括开始同步、取消同步等操作
+ * 注意: 当前版本中，同步功能已临时禁用
+ */
 package net.micode.notes.gtask.remote;
 
 import android.app.Activity;
@@ -23,43 +29,85 @@ import android.content.Intent;
 import android.os.Bundle;
 import android.os.IBinder;
 
+/**
+ * Google Tasks同步服务类
+ * 
+ * 该服务负责处理便签与Google Tasks的同步操作
+ * 提供开始同步、取消同步等功能，并通过广播通知同步状态
+ * 注意：当前版本中，同步功能已临时禁用
+ */
 public class GTaskSyncService extends Service {
+    /** Intent参数：同步动作类型 */
     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;
 
+    /** 广播Action名称，用于通知同步状态 */
     public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
 
+    /** 广播参数：是否正在同步 */
     public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
 
+    /** 广播参数：同步进度消息 */
     public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
 
+    // /** 同步任务对象 */
     // private static GTaskASyncTask mSyncTask = null;
 
+    /** 同步进度消息 */
     private static String mSyncProgress = "";
 
+    /**
+     * 开始同步操作
+     * 
+     * 注意：当前版本中，此功能已临时禁用
+     */
     private void startSync() {
         // Temporarily disabled sync functionality
         sendBroadcast("Sync functionality temporarily disabled");
         stopSelf();
     }
 
+    /**
+     * 取消同步操作
+     * 
+     * 注意：当前版本中，此功能已临时禁用
+     */
     private void cancelSync() {
         // Temporarily disabled sync functionality
         sendBroadcast("Sync cancelled");
     }
 
+    /**
+     * 服务创建时的回调方法
+     * 
+     * 注意：当前版本中，同步功能已临时禁用，此方法为空实现
+     */
     @Override
     public void onCreate() {
         // Temporarily disabled sync functionality
     }
 
+    /**
+     * 服务启动时的回调方法
+     * 
+     * 根据Intent中的参数执行相应的同步操作
+     * 
+     * @param intent 启动服务的Intent
+     * @param flags 服务启动标志
+     * @param startId 服务启动ID
+     * @return 服务启动模式
+     */
     @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)) {
@@ -77,23 +125,48 @@ public class GTaskSyncService extends Service {
         return super.onStartCommand(intent, flags, startId);
     }
 
+    /**
+     * 内存不足时的回调方法
+     * 
+     * 注意：当前版本中，同步功能已临时禁用，此方法为空实现
+     */
     @Override
     public void onLowMemory() {
         // Temporarily disabled sync functionality
     }
 
+    /**
+     * 绑定服务时的回调方法
+     * 
+     * @param intent 绑定服务的Intent
+     * @return 返回null，不支持绑定
+     */
     public IBinder onBind(Intent intent) {
         return null;
     }
 
+    /**
+     * 发送同步状态广播
+     * 
+     * @param msg 同步进度消息
+     */
     public void sendBroadcast(String msg) {
+        // 保存同步进度消息
         mSyncProgress = msg;
+        // 创建广播Intent
         Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
+        // 设置同步状态参数
         intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, false);
         intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
+        // 发送广播
         sendBroadcast(intent);
     }
 
+    /**
+     * 静态方法：启动同步服务
+     * 
+     * @param activity 活动上下文
+     */
     public static void startSync(Activity activity) {
         // Temporarily disabled sync functionality
         Intent intent = new Intent(activity, GTaskSyncService.class);
@@ -101,16 +174,31 @@ public class GTaskSyncService extends Service {
         activity.startService(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 当前版本始终返回false，因为同步功能已临时禁用
+     */
     public static boolean isSyncing() {
         return false; // Temporarily disabled sync functionality
     }
 
+    /**
+     * 静态方法：获取同步进度消息
+     * 
+     * @return 同步进度消息
+     */
     public static String getProgressString() {
         return mSyncProgress;
     }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: Note.java
+ * 描述: 便签数据模型类，用于管理便签的创建、更新和同步
+ * 作用: 提供便签数据的CRUD操作接口，是应用模型层的核心类之一
+ */
 package net.micode.notes.model;
 import android.content.ContentProviderOperation;
 import android.content.ContentProviderResult;
@@ -33,16 +38,31 @@ 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";
+    
     /**
-     * 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);
@@ -50,8 +70,11 @@ public class Note {
         values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
         values.put(NoteColumns.LOCAL_MODIFIED, 1);
         values.put(NoteColumns.PARENT_ID, folderId);
+        
+        // 插入便签记录并获取URI
         Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
 
+        // 从URI中提取便签ID
         long noteId = 0;
         try {
             noteId = Long.valueOf(uri.getPathSegments().get(1));
@@ -59,52 +82,106 @@ public class Note {
             Log.e(TAG, "Get note id error :" + e.toString());
             noteId = 0;
         }
+        
+        // 验证便签ID有效性
         if (noteId == -1) {
             throw new IllegalStateException("Wrong note id:" + noteId);
         }
         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 同步成功返回true，失败返回false
+     */
     public boolean syncNote(Context context, long noteId) {
+        // 验证便签ID有效性
         if (noteId <= 0) {
             throw new IllegalArgumentException("Wrong note id:" + noteId);
         }
 
+        // 如果没有本地修改，直接返回成功
         if (!isLocalModified()) {
             return true;
         }
@@ -114,6 +191,7 @@ public class Note {
          * {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
          * note data info
          */
+        // 更新便签基本信息
         if (context.getContentResolver().update(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
                 null) == 0) {
@@ -122,6 +200,7 @@ public class Note {
         }
         mNoteDiffValues.clear();
 
+        // 更新便签内容数据
         if (mNoteData.isLocalModified()
                 && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
             return false;
@@ -130,17 +209,30 @@ public class Note {
         return true;
     }
 
+    /**
+     * 便签数据内部类
+     * 
+     * 管理便签的文本数据和通话记录数据
+     */
     private class NoteData {
+        /** 文本数据ID */
         private long mTextDataId;
 
+        /** 文本数据值 */
         private ContentValues mTextDataValues;
 
+        /** 通话记录数据ID */
         private long mCallDataId;
 
+        /** 通话记录数据值 */
         private ContentValues mCallDataValues;
 
+        /** 日志标签 */
         private static final String TAG = "NoteData";
 
+        /**
+         * 构造函数，初始化便签数据
+         */
         public NoteData() {
             mTextDataValues = new ContentValues();
             mCallDataValues = new ContentValues();
@@ -148,10 +240,20 @@ public class Note {
             mCallDataId = 0;
         }
 
+        /**
+         * 检查数据是否在本地被修改
+         * 
+         * @return 如果数据被修改返回true，否则返回false
+         */
         boolean isLocalModified() {
             return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
         }
 
+        /**
+         * 设置文本数据ID
+         * 
+         * @param id 文本数据ID
+         */
         void setTextDataId(long id) {
             if(id <= 0) {
                 throw new IllegalArgumentException("Text data id should larger than 0");
@@ -159,6 +261,11 @@ public class Note {
             mTextDataId = id;
         }
 
+        /**
+         * 设置通话记录数据ID
+         * 
+         * @param id 通话记录数据ID
+         */
         void setCallDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Call data id should larger than 0");
@@ -166,32 +273,59 @@ 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());
         }
 
+        /**
+         * 将便签数据推送到ContentResolver
+         * 
+         * @param context 上下文环境
+         * @param noteId 便签ID
+         * @return 成功返回便签URI，失败返回null
+         */
         Uri pushIntoContentResolver(Context context, long noteId) {
             /**
              * Check for safety
              */
+            // 验证便签ID有效性
             if (noteId <= 0) {
                 throw new IllegalArgumentException("Wrong note id:" + noteId);
             }
 
+            // 创建批量操作列表
             ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
             ContentProviderOperation.Builder builder = null;
 
+            // 处理文本数据
             if(mTextDataValues.size() > 0) {
                 mTextDataValues.put(DataColumns.NOTE_ID, noteId);
                 if (mTextDataId == 0) {
+                    // 新建文本数据
                     mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
                     Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
                             mTextDataValues);
@@ -203,6 +337,7 @@ public class Note {
                         return null;
                     }
                 } else {
+                    // 更新现有文本数据
                     builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mTextDataId));
                     builder.withValues(mTextDataValues);
@@ -211,9 +346,11 @@ public class Note {
                 mTextDataValues.clear();
             }
 
+            // 处理通话记录数据
             if(mCallDataValues.size() > 0) {
                 mCallDataValues.put(DataColumns.NOTE_ID, noteId);
                 if (mCallDataId == 0) {
+                    // 新建通话记录数据
                     mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
                     Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
                             mCallDataValues);
@@ -225,6 +362,7 @@ public class Note {
                         return null;
                     }
                 } else {
+                    // 更新现有通话记录数据
                     builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mCallDataId));
                     builder.withValues(mCallDataValues);
@@ -233,6 +371,7 @@ public class Note {
                 mCallDataValues.clear();
             }
 
+            // 执行批量操作
             if (operationList.size() > 0) {
                 try {
                     ContentProviderResult[] results = context.getContentResolver().applyBatch(

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: WorkingNote.java
+ * 描述: 便签工作模型类，用于在UI层和数据层之间进行交互
+ * 作用: 提供便签编辑、保存、加载等操作的高级接口，管理便签的各种属性和状态
+ */
 package net.micode.notes.model;
 
 import android.appwidget.AppWidgetManager;
@@ -31,37 +36,59 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.Notes.TextNote;
 import net.micode.notes.tool.ResourceParser.NoteBgResources;
 
-
+/**
+ * 便签工作模型类
+ * 
+ * 该类是应用的核心模型类，负责便签数据的加载、编辑和保存操作
+ * 提供了便签的所有属性访问和修改方法，如内容、背景颜色、提醒时间等
+ * 作为UI层和数据层之间的桥梁，处理便签的各种状态变化
+ */
 public class WorkingNote {
-    // Note for the working note
+    /** 底层便签数据模型 */
     private Note mNote;
-    // Note Id
+    
+    /** 便签ID */
     private long mNoteId;
-    // Note content
+    
+    /** 便签内容 */
     private String mContent;
-    // Note mode
+    
+    /** 便签模式（普通模式或清单模式） */
     private int mMode;
 
+    /** 提醒时间 */
     private long mAlertDate;
 
+    /** 修改时间 */
     private long mModifiedDate;
 
+    /** 背景颜色ID */
     private int mBgColorId;
 
+    /** 小部件ID */
     private int mWidgetId;
 
+    /** 小部件类型 */
     private int mWidgetType;
 
+    /** 所属文件夹ID */
     private long mFolderId;
 
+    /** 上下文环境 */
     private Context mContext;
 
+    /** 日志标签 */
     private static final String TAG = "WorkingNote";
 
+    /** 是否已删除标记 */
     private boolean mIsDeleted;
 
+    /** 便签设置变更监听器 */
     private NoteSettingChangedListener mNoteSettingStatusListener;
 
+    /**
+     * 便签数据查询投影：定义查询便签数据时需要获取的列
+     */
     public static final String[] DATA_PROJECTION = new String[] {
             DataColumns.ID,
             DataColumns.CONTENT,
@@ -72,6 +99,9 @@ public class WorkingNote {
             DataColumns.DATA4,
     };
 
+    /**
+     * 便签查询投影：定义查询便签时需要获取的列
+     */
     public static final String[] NOTE_PROJECTION = new String[] {
             NoteColumns.PARENT_ID,
             NoteColumns.ALERTED_DATE,
@@ -81,27 +111,42 @@ public class WorkingNote {
             NoteColumns.MODIFIED_DATE
     };
 
+    /** 数据ID列索引 */
     private static final int DATA_ID_COLUMN = 0;
 
+    /** 数据内容列索引 */
     private static final int DATA_CONTENT_COLUMN = 1;
 
+    /** 数据MIME类型列索引 */
     private static final int DATA_MIME_TYPE_COLUMN = 2;
 
+    /** 数据模式列索引 */
     private static final int DATA_MODE_COLUMN = 3;
 
+    /** 便签父ID列索引 */
     private static final int NOTE_PARENT_ID_COLUMN = 0;
 
+    /** 便签提醒时间列索引 */
     private static final int NOTE_ALERTED_DATE_COLUMN = 1;
 
+    /** 便签背景颜色ID列索引 */
     private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
 
+    /** 便签小部件ID列索引 */
     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
+    /**
+     * 创建新便签的构造函数
+     * 
+     * @param context 上下文环境
+     * @param folderId 所属文件夹ID
+     */
     private WorkingNote(Context context, long folderId) {
         mContext = context;
         mAlertDate = 0;
@@ -114,7 +159,13 @@ 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,13 +175,18 @@ public class WorkingNote {
         loadNote();
     }
 
+    /**
+     * 从数据库加载便签基本信息
+     */
     private void loadNote() {
+        // 查询便签基本信息
         Cursor cursor = mContext.getContentResolver().query(
                 ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
                 null, null);
 
         if (cursor != null) {
             if (cursor.moveToFirst()) {
+                // 从查询结果中提取便签属性
                 mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
                 mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
                 mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
@@ -143,10 +199,15 @@ public class WorkingNote {
             Log.e(TAG, "No note with id:" + mNoteId);
             throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
         }
+        // 加载便签内容数据
         loadNoteData();
     }
 
+    /**
+     * 从数据库加载便签内容数据
+     */
     private void loadNoteData() {
+        // 查询便签内容数据
         Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
                 DataColumns.NOTE_ID + "=?", new String[] {
                     String.valueOf(mNoteId)
@@ -155,12 +216,15 @@ public class WorkingNote {
         if (cursor != null) {
             if (cursor.moveToFirst()) {
                 do {
+                    // 根据数据类型处理不同的便签内容
                     String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
                     if (DataConstants.NOTE.equals(type)) {
+                        // 处理文本便签数据
                         mContent = cursor.getString(DATA_CONTENT_COLUMN);
                         mMode = cursor.getInt(DATA_MODE_COLUMN);
                         mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
                     } else if (DataConstants.CALL_NOTE.equals(type)) {
+                        // 处理通话记录便签数据
                         mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
                     } else {
                         Log.d(TAG, "Wrong note type with type:" + type);
@@ -174,6 +238,16 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 创建空便签
+     * 
+     * @param context 上下文环境
+     * @param folderId 所属文件夹ID
+     * @param widgetId 小部件ID
+     * @param widgetType 小部件类型
+     * @param defaultBgColorId 默认背景颜色ID
+     * @return 新创建的WorkingNote对象
+     */
     public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
             int widgetType, int defaultBgColorId) {
         WorkingNote note = new WorkingNote(context, folderId);
@@ -183,12 +257,26 @@ public class WorkingNote {
         return note;
     }
 
+    /**
+     * 加载已有便签
+     * 
+     * @param context 上下文环境
+     * @param id 便签ID
+     * @return 加载的WorkingNote对象
+     */
     public static WorkingNote load(Context context, long id) {
         return new WorkingNote(context, id, 0);
     }
 
+    /**
+     * 保存便签到数据库
+     * 
+     * @return 保存成功返回true，失败返回false
+     */
     public synchronized boolean saveNote() {
+        // 检查便签是否值得保存
         if (isWorthSaving()) {
+            // 如果便签不存在于数据库中，创建新便签
             if (!existInDatabase()) {
                 if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
                     Log.e(TAG, "Create new note fail with id:" + mNoteId);
@@ -196,11 +284,13 @@ public class WorkingNote {
                 }
             }
 
+            // 同步便签数据到数据库
             mNote.syncNote(mContext, mNoteId);
 
             /**
              * Update widget content if there exist any widget of this note
              */
+            // 如果便签有关联的小部件，更新小部件内容
             if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                     && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
                     && mNoteSettingStatusListener != null) {
@@ -212,10 +302,24 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 检查便签是否存在于数据库中
+     * 
+     * @return 存在返回true，否则返回false
+     */
     public boolean existInDatabase() {
         return mNoteId > 0;
     }
 
+    /**
+     * 检查便签是否值得保存
+     * 判断条件：
+     * 1. 便签未被删除
+     * 2. 如果是新便签，内容不为空
+     * 3. 如果是已有便签，有本地修改
+     * 
+     * @return 值得保存返回true，否则返回false
+     */
     private boolean isWorthSaving() {
         if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
                 || (existInDatabase() && !mNote.isLocalModified())) {
@@ -225,10 +329,21 @@ 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,17 +354,29 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 标记便签为已删除/未删除
+     * 
+     * @param mark true表示已删除，false表示未删除
+     */
     public void markDeleted(boolean mark) {
         mIsDeleted = mark;
+        // 如果便签有关联的小部件，通知小部件变更
         if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                 && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
                 mNoteSettingStatusListener.onWidgetChanged();
         }
     }
 
+    /**
+     * 设置背景颜色ID
+     * 
+     * @param id 背景颜色ID
+     */
     public void setBgColorId(int id) {
         if (id != mBgColorId) {
             mBgColorId = id;
+            // 通知背景颜色变更
             if (mNoteSettingStatusListener != null) {
                 mNoteSettingStatusListener.onBackgroundColorChanged();
             }
@@ -257,8 +384,14 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置便签模式（普通模式或清单模式）
+     * 
+     * @param mode 便签模式
+     */
     public void setCheckListMode(int mode) {
         if (mMode != mode) {
+            // 通知便签模式变更
             if (mNoteSettingStatusListener != null) {
                 mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
             }
@@ -267,6 +400,11 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置小部件类型
+     * 
+     * @param type 小部件类型
+     */
     public void setWidgetType(int type) {
         if (type != mWidgetType) {
             mWidgetType = type;
@@ -274,6 +412,11 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置小部件ID
+     * 
+     * @param id 小部件ID
+     */
     public void setWidgetId(int id) {
         if (id != mWidgetId) {
             mWidgetId = id;
@@ -281,6 +424,11 @@ public class WorkingNote {
         }
     }
 
+    /**
+     * 设置便签内容
+     * 
+     * @param text 便签内容文本
+     */
     public void setWorkingText(String text) {
         if (!TextUtils.equals(mContent, text)) {
             mContent = text;
@@ -288,60 +436,130 @@ 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

java/net/micode/notes/tool/BackupUtils.java

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: BackupUtils.java
+ * 描述: 便签数据备份工具类，提供将便签导出为文本文件的功能
+ * 作用: 负责便签数据的备份操作，支持将便签内容导出到SD卡中的文本文件
+ */
 package net.micode.notes.tool;
 
 import android.content.Context;
@@ -35,12 +40,23 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.PrintStream;
 
-
+/**
+ * 便签备份工具类
+ * 
+ * 提供便签数据备份相关功能，主要用于将便签导出为文本文件
+ * 采用单例模式设计，确保全局只有一个实例
+ */
 public class BackupUtils {
     private static final String TAG = "BackupUtils";
-    // Singleton stuff
+    // 单例实例
     private static BackupUtils sInstance;
 
+    /**
+     * 获取BackupUtils单例实例
+     * 
+     * @param context 应用上下文
+     * @return BackupUtils实例
+     */
     public static synchronized BackupUtils getInstance(Context context) {
         if (sInstance == null) {
             sInstance = new BackupUtils(context);
@@ -49,43 +65,74 @@ public class BackupUtils {
     }
 
     /**
-     * Following states are signs to represents backup or restore
+     * 备份或恢复状态常量定义
-     * status
      */
-    // Currently, the sdcard is not mounted
+    // SD卡未挂载状态
     public static final int STATE_SD_CARD_UNMOUONTED           = 0;
-    // The backup file not exist
+    // 备份文件不存在状态
     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;
-    // Some run-time exception which causes restore or backup fails
+    // 系统错误状态（运行时异常导致备份或恢复失败）
     public static final int STATE_SYSTEM_ERROR                 = 3;
-    // Backup or restore success
+    // 操作成功状态
     public static final int STATE_SUCCESS                      = 4;
 
+    // 文本导出工具实例
     private TextExport mTextExport;
 
+    /**
+     * 私有构造函数，初始化文本导出工具
+     * 
+     * @param context 应用上下文
+     */
     private BackupUtils(Context context) {
         mTextExport = new TextExport(context);
     }
 
+    /**
+     * 检查外部存储是否可用
+     * 
+     * @return 如果外部存储可用返回true，否则返回false
+     */
     private static boolean externalStorageAvailable() {
         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
     }
 
+    /**
+     * 将便签导出为文本文件
+     * 
+     * @return 操作状态码，参见STATE_*常量
+     */
     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,
@@ -93,12 +140,16 @@ public class BackupUtils {
                 NoteColumns.TYPE
         };
 
+        // 便签ID列索引
         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 String[] DATA_PROJECTION = {
                 DataColumns.CONTENT,
                 DataColumns.MIME_TYPE,
@@ -108,39 +159,65 @@ public class BackupUtils {
                 DataColumns.DATA4,
         };
 
+        // 便签内容列索引
         private static final int DATA_COLUMN_CONTENT = 0;
 
+        // 便签MIME类型列索引
         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 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 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;
             mFileName = "";
             mFileDirectory = "";
         }
 
+        /**
+         * 获取指定索引的格式化模板
+         * 
+         * @param id 格式化模板索引
+         * @return 格式化模板字符串
+         */
         private String getFormat(int id) {
             return TEXT_FORMAT[id];
         }
 
         /**
-         * Export the folder identified by folder id to text
+         * 将指定文件夹下的便签导出为文本
+         * 
+         * @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 +226,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 +240,13 @@ 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,8 +256,9 @@ 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);
@@ -185,16 +267,18 @@ public class BackupUtils {
                                 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,7 +289,7 @@ public class BackupUtils {
                 }
                 dataCursor.close();
             }
-            // print a line separator between note
+            // 在便签之间打印一个分隔行
             try {
                 ps.write(new byte[] {
                         Character.LINE_SEPARATOR, Character.LETTER_NUMBER
@@ -216,20 +300,24 @@ public class BackupUtils {
         }
 
         /**
-         * Note will be exported as text which is user readable
+         * 将便签导出为文本文件
+         * 
+         * @return 操作状态码，参见STATE_*常量
          */
         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,7 +328,7 @@ 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);
@@ -283,7 +371,9 @@ public class BackupUtils {
         }
 
         /**
-         * Get a print stream pointed to the file {@generateExportedTextFile}
+         * 获取导出文本的打印流
+         * 
+         * @return 打印流对象，如果创建失败则返回null
          */
         private PrintStream getExportToTextPrintStream() {
             File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
@@ -310,7 +400,12 @@ 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();

java/net/micode/notes/tool/DataUtils.java

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: DataUtils.java
+ * 描述: 便签数据操作工具类，提供便签数据的批量处理和查询功能
+ * 作用: 封装对便签数据的各种操作，如批量删除、移动便签、查询便签信息等
+ */
 package net.micode.notes.tool;
 
 import android.content.ContentProviderOperation;
@@ -34,10 +39,24 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
 import java.util.ArrayList;
 import java.util.HashSet;
 
-
+/**
+ * 便签数据操作工具类
+ * 
+ * 提供便签数据的批量操作和查询功能，包括批量删除、移动便签、查询便签信息等
+ * 所有方法都是静态的，可以直接通过类名调用
+ */
 public class DataUtils {
     public static final String TAG = "DataUtils";
+    
+    /**
+     * 批量删除便签
+     * 
+     * @param resolver 内容解析器
+     * @param ids 要删除的便签ID集合
+     * @return 删除成功返回true，失败返回false
+     */
     public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+        // 检查参数有效性
         if (ids == null) {
             Log.d(TAG, "the ids is null");
             return true;
@@ -47,75 +66,113 @@ public class DataUtils {
             return true;
         }
 
+        // 创建批量操作列表
         ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
         for (long id : ids) {
+            // 不允许删除根文件夹
             if(id == Notes.ID_ROOT_FOLDER) {
                 Log.e(TAG, "Don't delete system folder root");
                 continue;
             }
+            // 为每个便签ID创建删除操作
             ContentProviderOperation.Builder builder = ContentProviderOperation
                     .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
             operationList.add(builder.build());
         }
+        
         try {
+            // 执行批量操作
             ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 检查操作结果
             if (results == null || results.length == 0 || results[0] == null) {
                 Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                 return false;
             }
             return true;
         } catch (RemoteException e) {
+            // 远程异常处理
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         } catch (OperationApplicationException e) {
+            // 操作应用异常处理
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         }
         return false;
     }
 
+    /**
+     * 将便签移动到指定文件夹
+     * 
+     * @param resolver 内容解析器
+     * @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);
+        values.put(NoteColumns.PARENT_ID, desFolderId);      // 设置新的父文件夹ID
-        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
+        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId); // 保存原始父文件夹ID
-        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);           // 标记为本地已修改
+        
+        // 更新便签数据
         resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
     }
 
+    /**
+     * 批量将便签移动到指定文件夹
+     * 
+     * @param resolver 内容解析器
+     * @param ids 要移动的便签ID集合
+     * @param folderId 目标文件夹ID
+     * @return 移动成功返回true，失败返回false
+     */
     public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
             long folderId) {
+        // 检查参数有效性
         if (ids == null) {
             Log.d(TAG, "the ids is null");
             return true;
         }
 
+        // 创建批量操作列表
         ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
         for (long id : ids) {
+            // 为每个便签ID创建更新操作
             ContentProviderOperation.Builder builder = ContentProviderOperation
                     .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
-            builder.withValue(NoteColumns.PARENT_ID, folderId);
+            builder.withValue(NoteColumns.PARENT_ID, folderId);    // 设置新的父文件夹ID
-            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
+            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);      // 标记为本地已修改
             operationList.add(builder.build());
         }
 
         try {
+            // 执行批量操作
             ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 检查操作结果
             if (results == null || results.length == 0 || results[0] == null) {
                 Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                 return false;
             }
             return true;
         } catch (RemoteException e) {
+            // 远程异常处理
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         } catch (OperationApplicationException e) {
+            // 操作应用异常处理
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         }
         return false;
     }
 
     /**
-     * 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,
+        // 查询类型为文件夹且不在回收站中的记录数量
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
                 new String[] { "COUNT(*)" },
                 NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
                 new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
@@ -125,10 +182,13 @@ public class DataUtils {
         if(cursor != null) {
             if(cursor.moveToFirst()) {
                 try {
+                    // 获取查询结果中的计数值
                     count = cursor.getInt(0);
                 } catch (IndexOutOfBoundsException e) {
+                    // 索引越界异常处理
                     Log.e(TAG, "get folder count failed:" + e.toString());
                 } finally {
+                    // 确保关闭游标
                     cursor.close();
                 }
             }
@@ -136,7 +196,16 @@ public class DataUtils {
         return count;
     }
 
+    /**
+     * 检查指定ID和类型的便签是否可见（不在回收站中）
+     * 
+     * @param resolver 内容解析器
+     * @param noteId 便签ID
+     * @param type 便签类型
+     * @return 如果便签可见返回true，否则返回false
+     */
     public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+        // 查询指定ID和类型的便签，且不在回收站中
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null,
                 NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
@@ -145,6 +214,7 @@ public class DataUtils {
 
         boolean exist = false;
         if (cursor != null) {
+            // 如果查询结果不为空，则便签存在且可见
             if (cursor.getCount() > 0) {
                 exist = true;
             }
@@ -153,12 +223,21 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查指定ID的便签是否存在于数据库中
+     * 
+     * @param resolver 内容解析器
+     * @param noteId 便签ID
+     * @return 如果便签存在返回true，否则返回false
+     */
     public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+        // 查询指定ID的便签
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null, null, null, null);
 
         boolean exist = false;
         if (cursor != null) {
+            // 如果查询结果不为空，则便签存在
             if (cursor.getCount() > 0) {
                 exist = true;
             }
@@ -167,12 +246,21 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查指定ID的数据是否存在于数据库中
+     * 
+     * @param resolver 内容解析器
+     * @param dataId 数据ID
+     * @return 如果数据存在返回true，否则返回false
+     */
     public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+        // 查询指定ID的数据
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
                 null, null, null, null);
 
         boolean exist = false;
         if (cursor != null) {
+            // 如果查询结果不为空，则数据存在
             if (cursor.getCount() > 0) {
                 exist = true;
             }
@@ -181,14 +269,24 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查可见文件夹中是否存在指定名称的文件夹
+     * 
+     * @param resolver 内容解析器
+     * @param name 文件夹名称
+     * @return 如果存在返回true，否则返回false
+     */
     public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
+        // 查询类型为文件夹、不在回收站中且名称匹配的记录
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
                 NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
                 " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
                 " AND " + NoteColumns.SNIPPET + "=?",
                 new String[] { name }, null);
+                
         boolean exist = false;
         if(cursor != null) {
+            // 如果查询结果不为空，则存在同名文件夹
             if(cursor.getCount() > 0) {
                 exist = true;
             }
@@ -197,7 +295,15 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 获取指定文件夹中的所有小部件属性
+     * 
+     * @param resolver 内容解析器
+     * @param folderId 文件夹ID
+     * @return 小部件属性集合，如果没有则返回null
+     */
     public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+        // 查询指定文件夹中便签的小部件ID和类型
         Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
                 new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
                 NoteColumns.PARENT_ID + "=?",
@@ -207,14 +313,17 @@ public class DataUtils {
         HashSet<AppWidgetAttribute> set = null;
         if (c != null) {
             if (c.moveToFirst()) {
+                // 创建小部件属性集合
                 set = new HashSet<AppWidgetAttribute>();
                 do {
                     try {
+                        // 提取小部件ID和类型
                         AppWidgetAttribute widget = new AppWidgetAttribute();
                         widget.widgetId = c.getInt(0);
                         widget.widgetType = c.getInt(1);
                         set.add(widget);
                     } catch (IndexOutOfBoundsException e) {
+                        // 索引越界异常处理
                         Log.e(TAG, e.toString());
                     }
                 } while (c.moveToNext());
@@ -224,7 +333,15 @@ public class DataUtils {
         return set;
     }
 
+    /**
+     * 根据便签ID获取关联的电话号码
+     * 
+     * @param resolver 内容解析器
+     * @param noteId 便签ID
+     * @return 电话号码字符串，如果没有则返回空字符串
+     */
     public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+        // 查询指定便签ID和MIME类型的通话记录数据
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.PHONE_NUMBER },
                 CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
@@ -233,62 +350,95 @@ public class DataUtils {
 
         if (cursor != null && cursor.moveToFirst()) {
             try {
+                // 返回电话号码
                 return cursor.getString(0);
             } catch (IndexOutOfBoundsException e) {
+                // 索引越界异常处理
                 Log.e(TAG, "Get call number fails " + e.toString());
             } finally {
+                // 确保关闭游标
                 cursor.close();
             }
         }
         return "";
     }
 
+    /**
+     * 根据电话号码和通话日期获取便签ID
+     * 
+     * @param resolver 内容解析器
+     * @param phoneNumber 电话号码
+     * @param callDate 通话日期
+     * @return 便签ID，如果没有找到则返回0
+     */
     public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+        // 查询匹配电话号码和通话日期的便签ID
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.NOTE_ID },
                 CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
                 + CallNote.PHONE_NUMBER + ",?)",
-                new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
+                new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber},
                 null);
 
         if (cursor != null) {
             if (cursor.moveToFirst()) {
                 try {
+                    // 返回便签ID
                     return cursor.getLong(0);
                 } catch (IndexOutOfBoundsException e) {
-                    Log.e(TAG, "Get call note id fails " + e.toString());
+                    Log.e(TAG, "Get note id by phone number and call date fails: " + e.toString());
+                } finally {
+                    cursor.close();
                 }
+            } else {
+                cursor.close();
             }
-            cursor.close();
         }
         return 0;
     }
 
+    /**
+     * 根据便签ID获取便签摘要
+     * 
+     * @param resolver 内容解析器
+     * @param noteId 便签ID
+     * @return 便签摘要，如果没有则返回空字符串
+     */
     public static String getSnippetById(ContentResolver resolver, long noteId) {
-        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+        // 查询指定便签ID的摘要
-                new String [] { NoteColumns.SNIPPET },
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
-                NoteColumns.ID + "=?",
+                new String[] { NoteColumns.SNIPPET },
-                new String [] { String.valueOf(noteId)},
+                null,
+                null,
                 null);
 
         if (cursor != null) {
-            String snippet = "";
             if (cursor.moveToFirst()) {
-                snippet = cursor.getString(0);
+                try {
+                    // 返回便签摘要
+                    return cursor.getString(0);
+                } catch (IndexOutOfBoundsException e) {
+                    Log.e(TAG, "Get snippet fails: " + e.toString());
+                } finally {
+                    cursor.close();
+                }
+            } else {
+                cursor.close();
             }
-            cursor.close();
-            return snippet;
         }
-        throw new IllegalArgumentException("Note is not found with id: " + noteId);
+        return "";
     }
 
+    /**
+     * 格式化便签摘要，处理特殊字符和长度
+     * 
+     * @param snippet 原始摘要
+     * @return 格式化后的摘要
+     */
     public static String getFormattedSnippet(String snippet) {
         if (snippet != null) {
-            snippet = snippet.trim();
+            // 替换换行符为空格
-            int index = snippet.indexOf('\n');
+            snippet = snippet.replace('\n', ' ');
-            if (index != -1) {
-                snippet = snippet.substring(0, index);
-            }
         }
         return snippet;
     }

java/net/micode/notes/tool/GTaskStringUtils.java

@@ -14,100 +14,301 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: GTaskStringUtils.java
+ * 描述: Google Tasks同步功能相关的字符串常量定义类
+ * 作用: 定义Google Tasks API交互所需的JSON字段名称和常量值，便于同步功能的实现
+ */
 package net.micode.notes.tool;
 
+/**
+ * Google Tasks字符串工具类
+ * 
+ * 该类定义了与Google Tasks同步功能相关的所有字符串常量，包括：
+ * - JSON字段名称
+ * - 操作类型常量
+ * - 实体类型常量
+ * - 文件夹名称前缀
+ * - 元数据标识符
+ * 
+ * 这些常量用于构建和解析与Google Tasks API交互的JSON数据
+ */
 public class GTaskStringUtils {
 
+    /**
+     * JSON字段名: 操作ID
+     * 用于标识同步操作的唯一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";
 
+    /**
+     * 操作类型常量: 创建
+     * 用于创建新的任务或列表
+     */
     public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
 
+    /**
+     * 操作类型常量: 获取全部
+     * 用于获取所有任务或列表
+     */
     public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
 
+    /**
+     * 操作类型常量: 移动
+     * 用于移动任务位置或更改任务所属列表
+     */
     public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
 
+    /**
+     * 操作类型常量: 更新
+     * 用于更新现有任务或列表的内容
+     */
     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
+     * 当前操作的列表ID
+     */
     public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
 
+    /**
+     * JSON字段名: 默认列表ID
+     * 用户的默认列表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
+     * 任务所属的列表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
+     * 创建操作后分配的新ID
+     */
     public final static String GTASK_JSON_NEW_ID = "new_id";
 
+    /**
+     * JSON字段名: 便签
+     * 包含多个便签的数组
+     */
     public final static String GTASK_JSON_NOTES = "notes";
 
+    /**
+     * JSON字段名: 父级ID
+     * 子任务的父任务ID
+     */
     public final static String GTASK_JSON_PARENT_ID = "parent_id";
 
+    /**
+     * JSON字段名: 前一个兄弟ID
+     * 列表中当前任务前一个任务的ID
+     */
     public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
 
+    /**
+     * JSON字段名: 结果
+     * API操作的结果数据
+     */
     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";
 
+    /**
+     * 实体类型常量: 组/文件夹
+     * 表示实体是一个组或文件夹
+     */
     public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
 
+    /**
+     * 实体类型常量: 任务
+     * 表示实体是一个任务
+     */
     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 Task ID
+     * 用于存储便签对应的Google Task 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";
 
 }

java/net/micode/notes/tool/ResourceParser.java

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: ResourceParser.java
+ * 描述: 资源解析工具类，用于管理应用中的各种资源ID和常量
+ * 作用: 提供便签背景颜色、文本大小等资源的统一访问接口，便于UI层使用
+ */
 package net.micode.notes.tool;
 
 import android.content.Context;
@@ -22,24 +27,84 @@ import android.preference.PreferenceManager;
 import net.micode.notes.R;
 import net.micode.notes.ui.NotesPreferenceActivity;
 
+/**
+ * 资源解析工具类
+ * 
+ * 该类负责管理和提供应用中使用的各种资源ID和常量，包括：
+ * - 便签背景颜色资源
+ * - 便签列表项背景资源
+ * - 小部件背景资源
+ * - 文本外观样式资源
+ * 
+ * 通过集中管理这些资源，使得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 {
+        /**
+         * 便签编辑背景资源数组
+         * 按颜色索引存储不同颜色的背景资源ID
+         */
         private final static int [] BG_EDIT_RESOURCES = new int [] {
             R.drawable.edit_yellow,
             R.drawable.edit_blue,
@@ -48,6 +113,10 @@ public class ResourceParser {
             R.drawable.edit_red
         };
 
+        /**
+         * 便签编辑标题背景资源数组
+         * 按颜色索引存储不同颜色的标题背景资源ID
+         */
         private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
             R.drawable.edit_title_yellow,
             R.drawable.edit_title_blue,
@@ -56,25 +125,57 @@ public class ResourceParser {
             R.drawable.edit_title_red
         };
 
+        /**
+         * 获取便签背景资源ID
+         * 
+         * @param id 颜色索引
+         * @return 对应颜色的背景资源ID
+         */
         public static int getNoteBgResource(int id) {
             return BG_EDIT_RESOURCES[id];
         }
 
+        /**
+         * 获取便签标题背景资源ID
+         * 
+         * @param 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)) {
+            // 随机选择一种背景颜色
             return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
         } else {
+            // 使用默认背景颜色
             return BG_DEFAULT_COLOR;
         }
     }
 
+    /**
+     * 便签列表项背景资源类
+     * 
+     * 提供便签列表中不同位置项目的背景资源
+     */
     public static class NoteItemBgResources {
+        /**
+         * 列表第一项背景资源数组
+         * 按颜色索引存储不同颜色的第一项背景资源ID
+         */
         private final static int [] BG_FIRST_RESOURCES = new int [] {
             R.drawable.list_yellow_up,
             R.drawable.list_blue_up,
@@ -83,6 +184,10 @@ public class ResourceParser {
             R.drawable.list_red_up
         };
 
+        /**
+         * 列表中间项背景资源数组
+         * 按颜色索引存储不同颜色的中间项背景资源ID
+         */
         private final static int [] BG_NORMAL_RESOURCES = new int [] {
             R.drawable.list_yellow_middle,
             R.drawable.list_blue_middle,
@@ -91,6 +196,10 @@ public class ResourceParser {
             R.drawable.list_red_middle
         };
 
+        /**
+         * 列表最后一项背景资源数组
+         * 按颜色索引存储不同颜色的最后一项背景资源ID
+         */
         private final static int [] BG_LAST_RESOURCES = new int [] {
             R.drawable.list_yellow_down,
             R.drawable.list_blue_down,
@@ -99,6 +208,10 @@ public class ResourceParser {
             R.drawable.list_red_down,
         };
 
+        /**
+         * 列表单项背景资源数组
+         * 按颜色索引存储不同颜色的单项背景资源ID（当列表只有一项时使用）
+         */
         private final static int [] BG_SINGLE_RESOURCES = new int [] {
             R.drawable.list_yellow_single,
             R.drawable.list_blue_single,
@@ -107,28 +220,66 @@ public class ResourceParser {
             R.drawable.list_red_single
         };
 
+        /**
+         * 获取列表第一项的背景资源ID
+         * 
+         * @param id 颜色索引
+         * @return 对应颜色的第一项背景资源ID
+         */
         public static int getNoteBgFirstRes(int id) {
             return BG_FIRST_RESOURCES[id];
         }
 
+        /**
+         * 获取列表最后一项的背景资源ID
+         * 
+         * @param id 颜色索引
+         * @return 对应颜色的最后一项背景资源ID
+         */
         public static int getNoteBgLastRes(int id) {
             return BG_LAST_RESOURCES[id];
         }
 
+        /**
+         * 获取列表单项的背景资源ID
+         * 
+         * @param id 颜色索引
+         * @return 对应颜色的单项背景资源ID
+         */
         public static int getNoteBgSingleRes(int id) {
             return BG_SINGLE_RESOURCES[id];
         }
 
+        /**
+         * 获取列表中间项的背景资源ID
+         * 
+         * @param id 颜色索引
+         * @return 对应颜色的中间项背景资源ID
+         */
         public static int getNoteBgNormalRes(int id) {
             return BG_NORMAL_RESOURCES[id];
         }
 
+        /**
+         * 获取文件夹背景资源ID
+         * 
+         * @return 文件夹背景资源ID
+         */
         public static int getFolderBgRes() {
             return R.drawable.list_folder;
         }
     }
 
+    /**
+     * 小部件背景资源类
+     * 
+     * 提供不同尺寸小部件的背景资源
+     */
     public static class WidgetBgResources {
+        /**
+         * 2x小部件背景资源数组
+         * 按颜色索引存储不同颜色的2x小部件背景资源ID
+         */
         private final static int [] BG_2X_RESOURCES = new int [] {
             R.drawable.widget_2x_yellow,
             R.drawable.widget_2x_blue,
@@ -137,10 +288,20 @@ public class ResourceParser {
             R.drawable.widget_2x_red,
         };
 
+        /**
+         * 获取2x小部件背景资源ID
+         * 
+         * @param id 颜色索引
+         * @return 对应颜色的2x小部件背景资源ID
+         */
         public static int getWidget2xBgResource(int id) {
             return BG_2X_RESOURCES[id];
         }
 
+        /**
+         * 4x小部件背景资源数组
+         * 按颜色索引存储不同颜色的4x小部件背景资源ID
+         */
         private final static int [] BG_4X_RESOURCES = new int [] {
             R.drawable.widget_4x_yellow,
             R.drawable.widget_4x_blue,
@@ -149,12 +310,27 @@ public class ResourceParser {
             R.drawable.widget_4x_red
         };
 
+        /**
+         * 获取4x小部件背景资源ID
+         * 
+         * @param id 颜色索引
+         * @return 对应颜色的4x小部件背景资源ID
+         */
         public static int getWidget4xBgResource(int id) {
             return BG_4X_RESOURCES[id];
         }
     }
 
+    /**
+     * 文本外观资源类
+     * 
+     * 提供不同大小的文本外观样式资源
+     */
     public static class TextAppearanceResources {
+        /**
+         * 文本外观样式资源数组
+         * 按大小索引存储不同大小的文本外观样式资源ID
+         */
         private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
             R.style.TextAppearanceNormal,
             R.style.TextAppearanceMedium,
@@ -162,11 +338,16 @@ public class ResourceParser {
             R.style.TextAppearanceSuper
         };
 
+        /**
+         * 获取文本外观样式资源ID
+         * 
+         * @param id 大小索引
+         * @return 对应大小的文本外观样式资源ID
+         */
         public static int getTexAppearanceResource(int id) {
             /**
-             * HACKME: Fix bug of store the resource id in shared preference.
+             * 修复Bug: 修复在共享偏好中存储资源ID的问题
-             * The id may larger than the length of resources, in this case,
+             * ID可能大于资源数组长度，在这种情况下返回默认字体大小
-             * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
              */
             if (id >= TEXTAPPEARANCE_RESOURCES.length) {
                 return BG_DEFAULT_FONT_SIZE;
@@ -174,6 +355,11 @@ public class ResourceParser {
             return TEXTAPPEARANCE_RESOURCES[id];
         }
 
+        /**
+         * 获取文本外观资源数组大小
+         * 
+         * @return 文本外观资源数组大小
+         */
         public static int getResourcesSize() {
             return TEXTAPPEARANCE_RESOURCES.length;
         }

java/net/micode/notes/ui/AlarmAlertActivity.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: AlarmAlertActivity.java
+ * 描述: 便签提醒闹钟弹窗界面
+ * 作用: 当便签设置的提醒时间到达时，显示提醒对话框并播放闹钟声音
+ * 功能: 
+ *   1. 在锁屏状态下也能显示提醒
+ *   2. 播放系统闹钟铃声
+ *   3. 显示便签内容预览
+ *   4. 提供快速进入便签编辑的选项
+ */
 package net.micode.notes.ui;
 
 import android.app.Activity;
@@ -39,119 +49,204 @@ import net.micode.notes.tool.DataUtils;
 
 import java.io.IOException;
 
-
+/**
+ * 便签提醒弹窗活动类
+ * 
+ * 当便签设置的提醒时间到达时，此活动会被启动，显示提醒对话框并播放闹钟声音。
+ * 实现了OnClickListener和OnDismissListener接口以处理对话框的交互事件。
+ */
 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
                     | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
         }
 
+        // 获取启动此活动的意图
         Intent intent = getIntent();
 
         try {
+            // 从URI中提取便签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;
         } catch (IllegalArgumentException e) {
+            // 处理参数错误异常
             e.printStackTrace();
             return;
         }
 
+        // 初始化媒体播放器
         mPlayer = new MediaPlayer();
+        // 检查便签是否存在且可见
         if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
+            // 显示提醒对话框
             showActionDialog();
+            // 播放闹钟声音
             playAlarmSound();
         } else {
+            // 如果便签不存在或不可见，结束活动
             finish();
         }
     }
 
+    /**
+     * 检查屏幕是否点亮
+     * 
+     * @return 如果屏幕点亮返回true，否则返回false
+     */
     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 {
+            // 否则使用标准闹钟音频流
             mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
         }
+        
         try {
+            // 设置数据源为闹钟铃声URI
             mPlayer.setDataSource(this, url);
+            // 准备媒体播放器
             mPlayer.prepare();
+            // 设置循环播放
             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
+            // 处理IO异常
             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);
+        // 如果屏幕已点亮，添加进入便签的按钮
         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();
     }
 
+    /**
+     * 停止闹钟声音播放
+     * 释放媒体播放器资源
+     */
     private void stopAlarmSound() {
         if (mPlayer != null) {
+            // 停止播放
             mPlayer.stop();
+            // 释放资源
             mPlayer.release();
+            // 置空播放器引用
             mPlayer = null;
         }
     }

java/net/micode/notes/ui/AlarmInitReceiver.java

@@ -14,6 +14,15 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: AlarmInitReceiver.java
+ * 描述: 便签提醒初始化广播接收器
+ * 作用: 在系统启动或应用启动时，重新初始化所有未触发的便签提醒
+ * 功能:
+ *   1. 监听系统启动广播
+ *   2. 查询数据库中所有未触发的提醒
+ *   3. 为每个未触发的提醒重新设置闹钟
+ */
 package net.micode.notes.ui;
 
 import android.app.AlarmManager;
@@ -27,20 +36,42 @@ import android.database.Cursor;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 
-
+/**
+ * 便签提醒初始化广播接收器类
+ * 
+ * 负责在系统启动或应用启动时，重新初始化所有未触发的便签提醒。
+ * 通过查询数据库中的提醒时间，为每个未触发的提醒重新设置系统闹钟。
+ * 这确保了即使在设备重启后，便签提醒功能仍然正常工作。
+ */
 public class AlarmInitReceiver extends BroadcastReceiver {
 
+    /**
+     * 数据库查询投影，定义需要获取的列
+     */
     private static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,
+        NoteColumns.ID,               // 便签ID
-        NoteColumns.ALERTED_DATE
+        NoteColumns.ALERTED_DATE      // 提醒时间
     };
 
+    /** 便签ID列索引 */
     private static final int COLUMN_ID                = 0;
+    
+    /** 提醒时间列索引 */
     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,
@@ -48,17 +79,29 @@ public class AlarmInitReceiver extends BroadcastReceiver {
                 null);
 
         if (c != null) {
+            // 如果有未触发的提醒
             if (c.moveToFirst()) {
                 do {
+                    // 获取提醒时间
                     long alertDate = c.getLong(COLUMN_ALERTED_DATE);
+                    
+                    // 创建用于触发AlarmReceiver的Intent
                     Intent sender = new Intent(context, AlarmReceiver.class);
+                    // 设置Intent的数据为便签的URI
                     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();
         }
     }

java/net/micode/notes/ui/AlarmReceiver.java

@@ -14,17 +14,41 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: AlarmReceiver.java
+ * 描述: 便签提醒闹钟广播接收器
+ * 作用: 接收系统闹钟服务发出的广播，启动提醒界面
+ * 功能:
+ *   1. 接收AlarmManager触发的闹钟广播
+ *   2. 将广播转发到AlarmAlertActivity以显示提醒界面
+ */
 package net.micode.notes.ui;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 
+/**
+ * 便签提醒闹钟广播接收器类
+ * 
+ * 当系统闹钟服务触发便签提醒时，此接收器会接收到广播。
+ * 接收器的主要职责是启动AlarmAlertActivity活动，显示提醒界面。
+ * 此类是便签提醒功能的中间环节，连接系统闹钟服务和提醒界面。
+ */
 public class AlarmReceiver extends BroadcastReceiver {
+    /**
+     * 接收闹钟广播时的回调方法
+     * 
+     * @param context 上下文环境
+     * @param intent 接收到的广播意图，包含便签URI数据
+     */
     @Override
     public void onReceive(Context context, Intent intent) {
+        // 将意图的目标类设置为AlarmAlertActivity
         intent.setClass(context, AlarmAlertActivity.class);
+        // 添加新任务标志，确保活动在新的任务栈中启动
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        // 启动提醒活动
         context.startActivity(intent);
     }
 }

java/net/micode/notes/ui/DateTimePicker.java

@@ -163,14 +163,33 @@ public class DateTimePicker extends FrameLayout {
                 int dayOfMonth, int hourOfDay, int minute);
     }
 
+    /**
+     * 使用当前系统时间创建日期时间选择器
+     * 
+     * @param context 上下文环境
+     */
     public DateTimePicker(Context context) {
         this(context, System.currentTimeMillis());
     }
 
+    /**
+     * 使用指定时间创建日期时间选择器
+     * 时间格式根据系统设置自动选择12小时制或24小时制
+     * 
+     * @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 +197,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.setOnValueChangedListener(mOnMinuteChangedListener);
 
+        // 初始化上午/下午选择器
         String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
         mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
         mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
@@ -198,19 +222,21 @@ public class DateTimePicker extends FrameLayout {
         mAmPmSpinner.setDisplayedValues(stringsForAmPm);
         mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
 
-        // update controls to initial state
+        // 更新控件到初始状态
         updateDateControl();
         updateHourControl();
         updateAmPmControl();
 
+        // 设置时间格式（12小时制或24小时制）
         set24HourView(is24HourView);
 
-        // set to current time
+        // 设置当前时间
         setCurrentDate(date);
 
+        // 设置控件启用状态
         setEnabled(isEnabled());
 
-        // set the content descriptions
+        // 完成初始化
         mInitialising = false;
     }
 

java/net/micode/notes/ui/DateTimePickerDialog.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: DateTimePickerDialog.java
+ * 描述: 日期时间选择对话框
+ * 作用: 提供一个对话框界面，让用户可以选择日期和时间
+ * 功能:
+ *   1. 基于AlertDialog，集成DateTimePicker控件
+ *   2. 提供确定和取消按钮
+ *   3. 自动更新对话框标题为当前选择的日期时间
+ *   4. 支持回调接口通知外部日期时间的设置
+ */
 package net.micode.notes.ui;
 
 import java.util.Calendar;
@@ -29,62 +39,134 @@ import android.content.DialogInterface.OnClickListener;
 import android.text.format.DateFormat;
 import android.text.format.DateUtils;
 
+/**
+ * 日期时间选择对话框类
+ * 
+ * 基于AlertDialog，集成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);
+        // 将秒设置为0
         mDate.set(Calendar.SECOND, 0);
+        // 设置选择器的当前日期
         mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
+        
+        // 设置确定按钮
         setButton(context.getString(R.string.datetime_dialog_ok), this);
+        // 设置取消按钮（不需要监听器，点击会自动关闭对话框）
         setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
+        
+        // 根据系统设置决定是否使用24小时制
         set24HourView(DateFormat.is24HourFormat(this.getContext()));
+        // 更新对话框标题
         updateTitle(mDate.getTimeInMillis());
     }
 
+    /**
+     * 设置是否使用24小时制显示时间
+     * 
+     * @param is24HourView 如果为true，使用24小时制；否则使用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_YEAR |   // 显示年份
-            DateUtils.FORMAT_SHOW_DATE |
+            DateUtils.FORMAT_SHOW_DATE |   // 显示日期
-            DateUtils.FORMAT_SHOW_TIME;
+            DateUtils.FORMAT_SHOW_TIME;    // 显示时间
+        
+        // 根据是否使用24小时制设置相应的格式
         flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
+        
+        // 设置对话框标题为格式化的日期时间字符串
         setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
     }
 
+    /**
+     * 确定按钮点击事件处理
+     * 
+     * @param arg0 对话框接口
+     * @param arg1 按钮ID
+     */
     public void onClick(DialogInterface arg0, int arg1) {
+        // 如果设置了监听器，通知日期时间已设置
         if (mOnDateTimeSetListener != null) {
             mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
         }
     }
-
 }

java/net/micode/notes/ui/DropdownMenu.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: DropdownMenu.java
+ * 描述: 下拉菜单组件
+ * 作用: 提供一个基于按钮和弹出菜单的下拉菜单组件
+ * 功能:
+ *   1. 将按钮与弹出菜单关联，点击按钮显示菜单
+ *   2. 支持设置菜单项点击监听器
+ *   3. 支持查找特定菜单项
+ *   4. 支持设置按钮标题
+ */
 package net.micode.notes.ui;
 
 import android.content.Context;
@@ -27,34 +37,77 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
 
 import net.micode.notes.R;
 
+/**
+ * 下拉菜单组件类
+ * 
+ * 这个类封装了一个基于按钮和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();
             }
         });
     }
 
+    /**
+     * 设置下拉菜单项点击监听器
+     * 
+     * @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);
     }

java/net/micode/notes/ui/FoldersListAdapter.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: FoldersListAdapter.java
+ * 描述: 文件夹列表适配器
+ * 作用: 为文件夹列表视图提供数据适配器，处理文件夹数据的显示
+ * 功能:
+ *   1. 将数据库中的文件夹数据适配到列表视图
+ *   2. 自定义文件夹列表项的布局和显示
+ *   3. 处理根文件夹的特殊显示
+ *   4. 提供获取文件夹名称的便捷方法
+ */
 package net.micode.notes.ui;
 
 import android.content.Context;
@@ -28,53 +38,116 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 
-
+/**
+ * 文件夹列表适配器类
+ * 
+ * 继承自CursorAdapter，用于将数据库中的文件夹数据适配到ListView中显示。
+ * 处理文件夹列表的显示逻辑，包括根文件夹的特殊显示和自定义列表项布局。
+ */
 public class FoldersListAdapter extends CursorAdapter {
+    /**
+     * 数据库查询投影，定义需要获取的列
+     */
     public static final String [] PROJECTION = {
-        NoteColumns.ID,
+        NoteColumns.ID,        // 文件夹ID
-        NoteColumns.SNIPPET
+        NoteColumns.SNIPPET    // 文件夹名称
     };
 
+    /** 文件夹ID列索引 */
     public static final int ID_COLUMN   = 0;
+    
+    /** 文件夹名称列索引 */
     public static final int NAME_COLUMN = 1;
 
+    /**
+     * 构造函数
+     * 
+     * @param context 上下文环境
+     * @param c 包含文件夹数据的游标
+     */
     public FoldersListAdapter(Context context, Cursor c) {
         super(context, c);
-        // TODO Auto-generated constructor stub
     }
 
+    /**
+     * 创建新的列表项视图
+     * 当ListView需要显示一个新的列表项时调用
+     * 
+     * @param context 上下文环境
+     * @param cursor 数据游标
+     * @param parent 父视图
+     * @return 新创建的列表项视图
+     */
     @Override
     public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        // 创建并返回一个新的文件夹列表项视图
         return new FolderListItem(context);
     }
 
+    /**
+     * 将数据绑定到列表项视图
+     * 当ListView需要显示数据到一个已创建的视图时调用
+     * 
+     * @param view 要绑定数据的视图
+     * @param context 上下文环境
+     * @param 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);
         }
     }
-
 }

java/net/micode/notes/ui/NoteEditActivity.java

@@ -14,6 +14,19 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NoteEditActivity.java
+ * 描述: 便签编辑界面
+ * 作用: 提供便签的创建、编辑、保存和设置功能
+ * 功能:
+ *   1. 便签内容编辑
+ *   2. 便签背景颜色设置
+ *   3. 字体大小设置
+ *   4. 提醒时间设置
+ *   5. 支持普通文本和清单模式切换
+ *   6. 支持便签分享和发送到桌面
+ *   7. 支持便签删除和保存
+ */
 package net.micode.notes.ui;
 
 import android.app.Activity;
@@ -71,19 +84,44 @@ import java.util.Map;
 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;
     }
 
+    /** 背景颜色选择器按钮ID与颜色值的映射 */
     private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
     static {
         sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@@ -93,6 +131,7 @@ 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 +141,7 @@ 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 +150,7 @@ 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,59 +159,94 @@ 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 EditText mNoteEditor;
 
+    /** 便签编辑器面板 */
     private View mNoteEditorPanel;
 
+    /** 当前工作的便签对象 */
     private WorkingNote mWorkingNote;
 
+    /** 共享首选项对象 */
     private SharedPreferences mSharedPrefs;
+    
+    /** 当前字体大小ID */
     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;
 
+    /**
+     * 活动创建时的回调方法
+     * 初始化活动状态和资源
+     * 
+     * @param savedInstanceState 保存的实例状态
+     */
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        // 设置内容视图为便签编辑布局
         this.setContentView(R.layout.note_edit);
 
+        // 如果没有保存的状态且初始化活动状态失败，则结束活动
         if (savedInstanceState == null && !initActivityState(getIntent())) {
             finish();
             return;
         }
+        // 初始化资源和视图
         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
+     * 恢复之前的便签编辑状态
+     * 
+     * @param savedInstanceState 保存的实例状态
      */
     @Override
     protected void onRestoreInstanceState(Bundle savedInstanceState) {
         super.onRestoreInstanceState(savedInstanceState);
+        // 如果有保存的便签ID，尝试恢复编辑状态
         if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
+            // 创建查看便签的意图
             Intent intent = new Intent(Intent.ACTION_VIEW);
+            // 设置便签ID
             intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
+            // 尝试初始化活动状态，如果失败则结束活动
             if (!initActivityState(intent)) {
                 finish();
                 return;
@@ -179,24 +255,36 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         }
     }
 
+    /**
+     * 初始化活动状态
+     * 根据意图加载便签数据或创建新便签
+     * 
+     * @param intent 启动活动的意图
+     * @return 如果初始化成功返回true，否则返回false
+     */
     private boolean initActivityState(Intent intent) {
         /**
-         * If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
+         * 如果用户指定了ACTION_VIEW但没有提供ID，
-         * then jump to the NotesListActivity
+         * 则跳转到便签列表活动
          */
         mWorkingNote = null;
         if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
+            // 获取便签ID
             long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
+            // 初始化用户查询字符串为空
             mUserQuery = "";
 
             /**
-             * Starting from the searched result
+             * 从搜索结果启动
              */
             if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
+                // 从搜索数据中获取便签ID
                 noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
+                // 获取用户搜索查询字符串
                 mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
             }
 
+            // 检查便签是否存在且可见
             if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
                 Intent jump = new Intent(this, NotesListActivity.class);
                 startActivity(jump);

java/net/micode/notes/ui/NoteEditText.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NoteEditText.java
+ * 描述: 便签编辑文本框控件
+ * 作用: 提供便签编辑的核心文本输入组件，支持特殊键处理、链接识别和上下文菜单
+ * 功能:
+ *   1. 处理回车键和删除键的特殊行为
+ *   2. 支持文本变化监听和回调
+ *   3. 支持URL链接的识别和处理
+ *   4. 提供自定义的触摸事件处理
+ */
 package net.micode.notes.ui;
 
 import android.content.Context;
@@ -37,15 +47,33 @@ import net.micode.notes.R;
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * 便签编辑文本框类
+ * 
+ * 继承自EditText，为便签应用提供自定义的文本编辑功能
+ * 处理特殊按键事件（如回车键、删除键）以支持便签的编辑操作
+ * 实现URL链接的识别和处理，支持点击链接执行相应操作
+ */
 public class NoteEditText extends EditText {
+    /** 日志标签 */
     private static final String TAG = "NoteEditText";
+    
+    /** 当前编辑框在列表中的索引位置 */
     private int mIndex;
+    
+    /** 删除操作前的光标位置，用于判断是否需要合并上一个编辑框 */
     private int mSelectionStartBeforeDelete;
 
+    /** 电话号码链接前缀 */
     private static final String SCHEME_TEL = "tel:" ;
+    
+    /** 网址链接前缀 */
     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);
@@ -54,56 +82,100 @@ public class NoteEditText extends EditText {
     }
 
     /**
-     * Call by the {@link NoteEditActivity} to delete or add edit text
+     * 文本视图变化监听器接口
+     * 由NoteEditActivity实现，用于响应编辑框的特殊操作
      */
     public interface OnTextViewChangeListener {
         /**
-         * Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
+         * 当删除键在文本为空且光标在开头位置时触发，用于删除当前编辑框
-         * and the text is null
+         * 
+         * @param index 当前编辑框的索引
+         * @param text 当前编辑框的文本内容
          */
         void onEditTextDelete(int index, String text);
 
         /**
-         * Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
+         * 当回车键按下时触发，用于在当前编辑框后添加新的编辑框
-         * happen
+         * 
+         * @param index 当前编辑框的索引
+         * @param text 分割后应该放入新编辑框的文本内容
          */
         void onEditTextEnter(int index, String text);
 
         /**
-         * Hide or show item option when text change
+         * 当文本内容变化时触发，用于控制项目选项的显示或隐藏
+         * 
+         * @param index 当前编辑框的索引
+         * @param hasText 是否有文本内容
          */
         void onTextChange(int index, boolean hasText);
     }
 
+    /** 文本视图变化监听器 */
     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();
@@ -121,15 +193,25 @@ 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:
+                // 如果设置了监听器，回车键由Activity处理
                 if (mOnTextViewChangeListener != null) {
                     return false;
                 }
                 break;
             case KeyEvent.KEYCODE_DEL:
+                // 记录删除前的光标位置，用于判断是否需要与上一个编辑框合并
                 mSelectionStartBeforeDelete = getSelectionStart();
                 break;
             default:
@@ -138,11 +220,21 @@ 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,9 +245,11 @@ 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));
+                    // 通知监听器创建新的编辑框
                     mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text);
                 } else {
                     Log.d(TAG, "OnTextViewChangeListener was not seted");
@@ -167,9 +261,18 @@ 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,8 +282,15 @@ public class NoteEditText extends EditText {
         super.onFocusChanged(focused, direction, previouslyFocusedRect);
     }
 
+    /**
+     * 创建上下文菜单
+     * 为识别到的URL链接提供操作选项
+     * 
+     * @param menu 上下文菜单
+     */
     @Override
     protected void onCreateContextMenu(ContextMenu menu) {
+        // 检查文本中是否包含URL链接
         if (getText() instanceof Spanned) {
             int selStart = getSelectionStart();
             int selEnd = getSelectionEnd();
@@ -188,8 +298,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) {
@@ -202,10 +314,11 @@ public class NoteEditText extends EditText {
                     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;
                             }

java/net/micode/notes/ui/NoteItemData.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NoteItemData.java
+ * 描述: 便签列表项数据模型类
+ * 作用: 封装便签列表中单个便签或文件夹的数据信息，提供数据访问接口
+ * 功能:
+ *   1. 从数据库游标中提取便签数据
+ *   2. 提供便签属性的访问方法
+ *   3. 判断便签在列表中的位置状态（首项、末项等）
+ *   4. 处理通话记录便签的特殊逻辑
+ */
 package net.micode.notes.ui;
 
 import android.content.Context;
@@ -25,8 +35,15 @@ import net.micode.notes.data.Notes;
 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,
@@ -42,41 +59,79 @@ public class NoteItemData {
         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（所属文件夹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 包含便签数据的游标
+     */
     public NoteItemData(Context context, Cursor cursor) {
+        // 从游标中提取基本属性
         mId = cursor.getLong(ID_COLUMN);
         mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
         mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
@@ -86,16 +141,20 @@ 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);
         mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
         mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
 
+        // 处理通话记录便签的特殊逻辑
         mPhoneNumber = "";
         if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
+            // 获取通话记录关联的电话号码
             mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
             if (!TextUtils.isEmpty(mPhoneNumber)) {
+                // 尝试获取联系人姓名，如果没有则使用电话号码作为名称
                 mName = Contact.getContact(context, mPhoneNumber);
                 if (mName == null) {
                     mName = mPhoneNumber;
@@ -106,27 +165,40 @@ public class NoteItemData {
         if (mName == null) {
             mName = "";
         }
+        // 检查便签在列表中的位置状态
         checkPostion(cursor);
     }
 
+    /**
+     * 检查便签在列表中的位置状态
+     * 确定便签是否为首项、末项、单项等
+     * 
+     * @param cursor 包含便签数据的游标
+     */
     private void checkPostion(Cursor cursor) {
+        // 检查是否为最后一项、第一项或唯一一项
         mIsLastItem = cursor.isLast() ? true : false;
         mIsFirstItem = cursor.isFirst() ? true : false;
         mIsOnlyOneItem = (cursor.getCount() == 1);
         mIsMultiNotesFollowingFolder = false;
         mIsOneNoteFollowingFolder = false;
 
+        // 检查是否为文件夹后的便签
         if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
             int position = cursor.getPosition();
             if (cursor.moveToPrevious()) {
+                // 检查前一项是否为文件夹
                 if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
                         || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
                     if (cursor.getCount() > (position + 1)) {
+                        // 文件夹后有多个便签
                         mIsMultiNotesFollowingFolder = true;
                     } else {
+                        // 文件夹后只有一个便签
                         mIsOneNoteFollowingFolder = true;
                     }
                 }
+                // 恢复游标位置
                 if (!cursor.moveToNext()) {
                     throw new IllegalStateException("cursor move to previous but can't move back");
                 }
@@ -134,90 +206,202 @@ 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（所属文件夹ID）
+     * 
+     * @return 父ID
+     */
     public long getParentId() {
         return mParentId;
     }
 
+    /**
+     * 获取便签数量（对于文件夹）
+     * 
+     * @return 便签数量
+     */
     public int getNotesCount() {
         return mNotesCount;
     }
 
+    /**
+     * 获取文件夹ID
+     * 与getParentId()功能相同，提供另一个命名接口
+     * 
+     * @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));
     }
 
+    /**
+     * 从游标中获取便签类型的静态方法
+     * 
+     * @param cursor 包含便签数据的游标
+     * @return 便签类型
+     */
     public static int getNoteType(Cursor cursor) {
         return cursor.getInt(TYPE_COLUMN);
     }

java/net/micode/notes/ui/NotesListActivity.java

@@ -14,6 +14,18 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NotesListActivity.java
+ * 描述: 便签应用的主界面活动
+ * 作用: 显示便签和文件夹列表，提供便签的创建、编辑、删除等操作入口
+ * 功能:
+ *   1. 显示便签和文件夹列表
+ *   2. 提供便签的创建、编辑、删除等操作
+ *   3. 支持便签的多选操作和批量处理
+ *   4. 提供文件夹的创建、编辑、删除等管理功能
+ *   5. 支持便签的搜索和导出
+ *   6. 支持Google账户同步设置入口
+ */
 package net.micode.notes.ui;
 
 import android.app.Activity;
@@ -78,63 +90,110 @@ 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;
 
+    /** 文件夹删除菜单项ID */
     private static final int MENU_FOLDER_DELETE = 0;
 
+    /** 文件夹查看菜单项ID */
     private static final int MENU_FOLDER_VIEW = 1;
 
+    /** 文件夹重命名菜单项ID */
     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;
 
+    /** 触摸事件原始Y坐标 */
     private int mOriginY;
 
+    /** 触摸事件分发Y坐标 */
     private int mDispatchY;
 
+    /** 标题栏文本视图 */
     private TextView mTitleBar;
 
+    /** 当前文件夹ID */
     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 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)";
 
+    /** 打开便签请求码 */
     private final static int REQUEST_CODE_OPEN_NODE = 102;
+    
+    /** 新建便签请求码 */
     private final static int REQUEST_CODE_NEW_NODE  = 103;
 
+    /**
+     * 活动创建时的初始化
+     * 
+     * @param savedInstanceState 保存的实例状态
+     */
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -142,27 +201,41 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         initResources();
 
         /**
-         * Insert an introduction when user firstly use this application
+         * 首次使用应用时添加介绍便签
          */
         setAppInfoFromRawRes();
     }
 
+    /**
+     * 处理活动结果
+     * 
+     * @param requestCode 请求码
+     * @param resultCode 结果码
+     * @param data 返回的数据
+     */
     @Override
     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
         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)) {
+            // 首次使用应用，需要添加介绍便签
             StringBuilder sb = new StringBuilder();
             InputStream in = null;
             try {
+                 // 读取介绍文件内容
                  in = getResources().openRawResource(R.raw.introduction);
                 if (in != null) {
                     InputStreamReader isr = new InputStreamReader(in);
@@ -190,11 +263,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                 }
             }
 
+            // 创建介绍便签并保存
             WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
                     AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
                     ResourceParser.RED);
             note.setWorkingText(sb.toString());
             if (note.saveNote()) {
+                // 保存成功后，更新首选项标记，下次不再添加介绍
                 sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit();
             } else {
                 Log.e(TAG, "Save introduction note error");
@@ -203,26 +278,42 @@ 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());
         mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+        
+        // 初始化列表视图
         mNotesListView = (ListView) findViewById(R.id.notes_list);
         mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
                 null, false);
         mNotesListView.setOnItemClickListener(new OnListItemClickListener());
         mNotesListView.setOnItemLongClickListener(this);
+        
+        // 设置列表适配器
         mNotesListAdapter = new NotesListAdapter(this);
         mNotesListView.setAdapter(mNotesListAdapter);
+        
+        // 初始化添加新便签按钮
         mAddNewNote = (Button) findViewById(R.id.btn_new_note);
         mAddNewNote.setOnClickListener(this);
         mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener());
+        
+        // 初始化其他变量
         mDispatch = false;
         mDispatchY = 0;
         mOriginY = 0;
@@ -231,17 +322,40 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
         mModeCallBack = new ModeCallback();
     }
 
+    /**
+     * 多选模式回调类
+     * 
+     * 处理便签列表的多选模式操作，包括菜单创建和项目选择
+     * 实现ActionMode的回调接口和菜单项点击监听器
+     */
     private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
+        /** 下拉菜单 */
         private DropdownMenu mDropDownMenu;
+        
+        /** 操作模式 */
         private ActionMode mActionMode;
+        
+        /** 移动菜单项 */
         private MenuItem mMoveMenu;
 
+        /**
+         * 创建操作模式时调用
+         * 初始化菜单项和操作模式
+         * 
+         * @param mode 操作模式
+         * @param menu 菜单
+         * @return 是否成功创建
+         */
         public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+            // 加载菜单资源
             getMenuInflater().inflate(R.menu.note_list_options, menu);
             menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
             mMoveMenu = menu.findItem(R.id.move);
+            
+            // 根据当前文件夹决定是否显示移动菜单
             if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER
                     || DataUtils.getUserFolderCount(mContentResolver) == 0) {
+                // 通话记录文件夹或没有用户文件夹时不显示移动菜单
                 mMoveMenu.setVisible(false);
             } else {
                 mMoveMenu.setVisible(true);

java/net/micode/notes/ui/NotesListAdapter.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NotesListAdapter.java
+ * 描述: 便签列表数据适配器
+ * 作用: 连接数据源与ListView，管理列表项的创建和数据绑定
+ * 功能:
+ *   1. 创建和复用列表项视图
+ *   2. 将数据绑定到列表项视图
+ *   3. 管理列表的多选模式
+ *   4. 提供选中项的数据访问方法
+ */
 package net.micode.notes.ui;
 
 import android.content.Context;
@@ -30,19 +40,46 @@ import java.util.HashMap;
 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;
 
+    /**
+     * 小部件属性类
+     * 用于存储小部件的ID和类型
+     */
     public static class AppWidgetAttribute {
+        /** 小部件ID */
         public int widgetId;
+        
+        /** 小部件类型 */
         public int widgetType;
     };
 
+    /**
+     * 构造函数
+     * 
+     * @param context 上下文环境
+     */
     public NotesListAdapter(Context context) {
         super(context, null);
         mSelectedIndex = new HashMap<Integer, Boolean>();
@@ -50,38 +87,77 @@ public class NotesListAdapter extends CursorAdapter {
         mNotesCount = 0;
     }
 
+    /**
+     * 创建新的列表项视图
+     * 
+     * @param context 上下文环境
+     * @param cursor 数据游标
+     * @param parent 父视图
+     * @return 新创建的列表项视图
+     */
     @Override
     public View newView(Context context, Cursor cursor, ViewGroup parent) {
         return new NotesListItem(context);
     }
 
+    /**
+     * 将数据绑定到列表项视图
+     * 
+     * @param view 列表项视图
+     * @param context 上下文环境
+     * @param cursor 数据游标
+     */
     @Override
     public void bindView(View view, Context context, Cursor cursor) {
         if (view instanceof NotesListItem) {
+            // 创建数据对象并绑定到视图
             NoteItemData itemData = new NoteItemData(context, cursor);
             ((NotesListItem) view).bind(context, itemData, mChoiceMode,
                     isSelectedItem(cursor.getPosition()));
         }
     }
 
+    /**
+     * 设置指定位置项的选中状态
+     * 
+     * @param position 列表项位置
+     * @param checked 是否选中
+     */
     public void setCheckedItem(final int position, final boolean checked) {
         mSelectedIndex.put(position, checked);
         notifyDataSetChanged();
     }
 
+    /**
+     * 检查是否处于多选模式
+     * 
+     * @return 如果处于多选模式则返回true，否则返回false
+     */
     public boolean isInChoiceMode() {
         return mChoiceMode;
     }
 
+    /**
+     * 设置多选模式状态
+     * 
+     * @param mode 是否启用多选模式
+     */
     public void setChoiceMode(boolean mode) {
+        // 清空选中项
         mSelectedIndex.clear();
         mChoiceMode = mode;
     }
 
+    /**
+     * 全选或取消全选所有便签
+     * 
+     * @param checked 是否选中
+     */
     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 +165,11 @@ 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 +186,11 @@ 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 +214,11 @@ public class NotesListAdapter extends CursorAdapter {
         return itemSet;
     }
 
+    /**
+     * 获取选中项的数量
+     * 
+     * @return 选中项数量
+     */
     public int getSelectedCount() {
         Collection<Boolean> values = mSelectedIndex.values();
         if (null == values) {
@@ -143,11 +234,22 @@ 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;
@@ -155,23 +257,38 @@ public class NotesListAdapter extends CursorAdapter {
         return mSelectedIndex.get(position);
     }
 
+    /**
+     * 当数据内容变化时调用
+     * 重新计算便签数量
+     */
     @Override
     protected void onContentChanged() {
         super.onContentChanged();
         calcNotesCount();
     }
 
+    /**
+     * 更换数据游标
+     * 重新计算便签数量
+     * 
+     * @param cursor 新的数据游标
+     */
     @Override
     public void changeCursor(Cursor cursor) {
         super.changeCursor(cursor);
         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++;
                 }

java/net/micode/notes/ui/NotesListItem.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NotesListItem.java
+ * 描述: 便签列表项视图组件
+ * 作用: 提供便签列表中单个项目的视图表现，负责数据与UI的绑定
+ * 功能:
+ *   1. 显示便签或文件夹的基本信息（标题、时间、提醒图标等）
+ *   2. 根据便签类型和位置设置不同的背景样式
+ *   3. 支持多选模式下的勾选功能
+ *   4. 处理通话记录便签的特殊显示逻辑
+ */
 package net.micode.notes.ui;
 
 import android.content.Context;
@@ -29,18 +39,42 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
 
-
+/**
+ * 便签列表项视图类
+ * 
+ * 继承自LinearLayout，用于在列表中显示单个便签或文件夹
+ * 根据数据类型和状态设置不同的显示效果
+ * 处理多选模式下的勾选状态
+ */
 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 +82,17 @@ 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,7 +101,9 @@ public class NotesListItem extends LinearLayout {
         }
 
         mItemData = data;
+        // 根据不同类型的便签设置不同的显示效果
         if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+            // 通话记录文件夹的显示
             mCallName.setVisibility(View.GONE);
             mAlert.setVisibility(View.VISIBLE);
             mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
@@ -65,6 +111,7 @@ public class NotesListItem extends LinearLayout {
                     + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
             mAlert.setImageResource(R.drawable.call_record);
         } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
+            // 通话记录便签的显示
             mCallName.setVisibility(View.VISIBLE);
             mCallName.setText(data.getCallName());
             mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
@@ -76,15 +123,18 @@ public class NotesListItem extends LinearLayout {
                 mAlert.setVisibility(View.GONE);
             }
         } else {
+            // 普通便签和文件夹的显示
             mCallName.setVisibility(View.GONE);
             mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
 
             if (data.getType() == Notes.TYPE_FOLDER) {
+                // 文件夹显示
                 mTitle.setText(data.getSnippet()
                         + context.getString(R.string.format_folder_files_count,
                                 data.getNotesCount()));
                 mAlert.setVisibility(View.GONE);
             } else {
+                // 普通便签显示
                 mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
                 if (data.hasAlert()) {
                     mAlert.setImageResource(R.drawable.clock);
@@ -94,28 +144,46 @@ 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()) {
+                // 列表中最后一个便签
                 setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
             } else if (data.isFirst() || data.isMultiFollowingFolder()) {
+                // 列表中第一个便签或文件夹后的多个便签中的第一个
                 setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
             } else {
+                // 列表中间的便签
                 setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
             }
         } else {
+            // 文件夹使用固定的背景样式
             setBackgroundResource(NoteItemBgResources.getFolderBgRes());
         }
     }
 
+    /**
+     * 获取列表项关联的数据对象
+     * 
+     * @return 列表项数据对象
+     */
     public NoteItemData getItemData() {
         return mItemData;
     }

java/net/micode/notes/ui/NotesPreferenceActivity.java

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NotesPreferenceActivity.java
+ * 描述: 便签应用的设置界面
+ * 作用: 提供应用设置选项，特别是Google账户同步功能的配置
+ * 功能:
+ *   1. 管理Google账户同步设置
+ *   2. 提供同步按钮和状态显示
+ *   3. 处理账户选择和添加
+ *   4. 显示上次同步时间
+ */
 package net.micode.notes.ui;
 
 import android.accounts.Account;
@@ -47,53 +57,81 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.remote.GTaskSyncService;
 
-
+/**
+ * 便签设置活动类
+ * 
+ * 继承自PreferenceActivity，提供便签应用的设置界面
+ * 主要功能是配置Google账户同步，包括账户选择和同步操作
+ * 显示同步状态和上次同步时间
+ */
 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;
 
+    /** Google任务同步广播接收器 */
     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) {
@@ -106,6 +144,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                         }
                     }
                     if (!found) {
+                        // 找到新添加的账户，设置为同步账户
                         setSyncAccount(accountNew.name);
                         break;
                     }
@@ -113,9 +152,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             }
         }
 
+        // 刷新UI显示
         refreshUI();
     }
 
+    /**
+     * 活动销毁时的清理工作
+     */
     @Override
     protected void onDestroy() {
         if (mReceiver != null) {
@@ -124,6 +167,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         super.onDestroy();
     }
 
+    /**
+     * 加载账户首选项
+     * 设置账户选择的点击监听器
+     */
     private void loadAccountPreference() {
         mAccountCategory.removeAll();
 
@@ -135,14 +182,14 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             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();
@@ -154,12 +201,17 @@ 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) {
@@ -167,6 +219,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                 }
             });
         } else {
+            // 未同步，显示立即同步按钮
             syncButton.setText(getString(R.string.preferences_button_sync_immediately));
             syncButton.setOnClickListener(new View.OnClickListener() {
                 public void onClick(View v) {
@@ -174,13 +227,16 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                 }
             });
         }
+        // 只有设置了同步账户才启用同步按钮
         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,
@@ -193,14 +249,23 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
     }
 
+    /**
+     * 刷新UI显示
+     * 更新账户设置和同步按钮状态
+     */
     private void refreshUI() {
         loadAccountPreference();
         loadSyncButton();
     }
 
+    /**
+     * 显示选择账户对话框
+     * 列出所有Google账户供用户选择
+     */
     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));
@@ -210,6 +275,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         dialogBuilder.setCustomTitle(titleView);
         dialogBuilder.setPositiveButton(null, null);
 
+        // 获取所有Google账户
         Account[] accounts = getGoogleAccounts();
         String defAccount = getSyncAccountName(this);
 
@@ -217,6 +283,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         mHasAddedAccount = false;
 
         if (accounts.length > 0) {
+            // 显示账户列表
             CharSequence[] items = new CharSequence[accounts.length];
             final CharSequence[] itemMapping = items;
             int checkedItem = -1;
@@ -230,6 +297,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             dialogBuilder.setSingleChoiceItems(items, checkedItem,
                     new DialogInterface.OnClickListener() {
                         public void onClick(DialogInterface dialog, int which) {
+                            // 选择账户后设置为同步账户
                             setSyncAccount(itemMapping[which].toString());
                             dialog.dismiss();
                             refreshUI();
@@ -237,12 +305,14 @@ 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[] {
@@ -254,9 +324,14 @@ 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,6 +340,7 @@ 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),
@@ -273,8 +349,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
             public void onClick(DialogInterface dialog, int which) {
                 if (which == 0) {
+                    // 更改账户
                     showSelectAccountAlertDialog();
                 } else if (which == 1) {
+                    // 移除账户
                     removeSyncAccount();
                     refreshUI();
                 }
@@ -283,13 +361,24 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         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 +388,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
             }
             editor.commit();
 
-            // clean up last sync time
+            // 清除上次同步时间
             setLastSyncTime(this, 0);
 
-            // clean up local gtask related info
+            // 清除本地Google任务相关信息
             new Thread(new Runnable() {
                 public void run() {
                     ContentValues values = new ContentValues();
@@ -312,13 +401,19 @@ 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 +424,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
         editor.commit();
 
-        // clean up local gtask related info
+        // 清除本地Google任务相关信息
         new Thread(new Runnable() {
             public void run() {
                 ContentValues values = new ContentValues();
@@ -340,12 +435,24 @@ 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,18 +461,33 @@ 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);
     }
 
+    /**
+     * Google任务同步广播接收器
+     * 用于接收同步服务的状态更新广播
+     */
     private class GTaskReceiver extends BroadcastReceiver {
 
+        /**
+         * 接收同步服务广播
+         * 更新UI显示同步状态
+         */
         @Override
         public void onReceive(Context context, Intent intent) {
             refreshUI();
             if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+                // 同步进行中，更新进度显示
                 TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
                 syncStatus.setText(intent
                         .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
@@ -374,9 +496,16 @@ public class NotesPreferenceActivity extends PreferenceActivity {
         }
     }
 
+    /**
+     * 处理选项菜单项点击事件
+     * 
+     * @param item 点击的菜单项
+     * @return 是否已处理事件
+     */
     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);

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NoteWidgetProvider.java
+ * 描述: 便签小部件提供者的抽象基类，定义了小部件的基本功能和行为
+ * 作用: 管理便签小部件的创建、更新和删除，处理小部件与便签数据的交互
+ */
 package net.micode.notes.widget;
 import android.app.PendingIntent;
 import android.appwidget.AppWidgetManager;
@@ -32,24 +37,54 @@ import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.ui.NoteEditActivity;
 import net.micode.notes.ui.NotesListActivity;
 
+/**
+ * 便签小部件提供者抽象基类
+ * 
+ * 该类继承自AppWidgetProvider，提供了便签小部件的基本功能实现，
+ * 包括小部件的更新、删除等操作，以及与便签数据的交互逻辑。
+ * 具体的小部件类型（如2x和4x）需要继承此类并实现抽象方法。
+ */
 public abstract class NoteWidgetProvider extends AppWidgetProvider {
+    /**
+     * 查询便签数据的投影列
+     * 定义了从数据库查询便签时需要获取的列
+     */
     public static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,
+        NoteColumns.ID,             // 便签ID
-        NoteColumns.BG_COLOR_ID,
+        NoteColumns.BG_COLOR_ID,    // 背景颜色ID
-        NoteColumns.SNIPPET
+        NoteColumns.SNIPPET         // 便签内容摘要
     };
 
-    public static final int COLUMN_ID           = 0;
+    /**
-    public static final int COLUMN_BG_COLOR_ID  = 1;
+     * 查询结果列索引常量
-    public static final int COLUMN_SNIPPET      = 2;
+     */
+    public static final int COLUMN_ID           = 0;  // ID列索引
+    public static final int COLUMN_BG_COLOR_ID  = 1;  // 背景颜色ID列索引
+    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) {
+        // 创建更新数据
         ContentValues values = new ContentValues();
+        // 将小部件ID设置为无效值，表示该便签不再与任何小部件关联
         values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
+        
+        // 遍历所有被删除的小部件ID
         for (int i = 0; i < appWidgetIds.length; i++) {
+            // 更新数据库，清除小部件ID与便签的关联
             context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
                     values,
                     NoteColumns.WIDGET_ID + "=?",
@@ -57,7 +92,16 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
         }
     }
 
+    /**
+     * 获取与指定小部件ID关联的便签信息
+     * 
+     * @param context 上下文环境
+     * @param widgetId 小部件ID
+     * @return 包含便签信息的Cursor对象，如果没有找到则返回空Cursor
+     */
     private Cursor getNoteWidgetInfo(Context context, int widgetId) {
+        // 查询与指定小部件ID关联的便签数据
+        // 条件：匹配小部件ID且不在回收站中
         return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                 PROJECTION,
                 NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
@@ -65,68 +109,130 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
                 null);
     }
 
+    /**
+     * 更新小部件
+     * 
+     * 供子类调用的公共更新方法，默认非隐私模式
+     * 
+     * @param context 上下文环境
+     * @param appWidgetManager 小部件管理器
+     * @param appWidgetIds 需要更新的小部件ID数组
+     */
     protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+        // 调用私有更新方法，隐私模式设为false
         update(context, appWidgetManager, appWidgetIds, false);
     }
 
+    /**
+     * 更新小部件的私有实现
+     * 
+     * 根据小部件ID更新对应的小部件显示内容和点击行为
+     * 
+     * @param context 上下文环境
+     * @param appWidgetManager 小部件管理器
+     * @param appWidgetIds 需要更新的小部件ID数组
+     * @param privacyMode 是否为隐私模式，隐私模式下不显示便签内容
+     */
     private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
             boolean privacyMode) {
+        // 遍历所有需要更新的小部件
         for (int i = 0; i < appWidgetIds.length; i++) {
+            // 检查小部件ID是否有效
             if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
+                // 设置默认背景ID和空内容
                 int bgId = ResourceParser.getDefaultBgId(context);
                 String snippet = "";
+                
+                // 创建打开便签编辑界面的Intent
                 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());
 
+                // 获取与小部件关联的便签信息
                 Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
                 if (c != null && c.moveToFirst()) {
+                    // 检查是否有多个便签关联到同一个小部件ID（异常情况）
                     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参数，用于打开现有便签
                     intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
                     intent.setAction(Intent.ACTION_VIEW);
                 } else {
+                    // 没有关联便签，设置默认提示文本
                     snippet = context.getResources().getString(R.string.widget_havenot_content);
+                    // 设置Intent参数，用于创建新便签
                     intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
                 }
 
+                // 关闭游标
                 if (c != null) {
                     c.close();
                 }
 
+                // 创建远程视图并设置背景
                 RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
                 rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
                 intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
+                
                 /**
-                 * 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获取对应的背景资源ID
+     * 子类需要实现此方法以提供不同尺寸小部件的背景资源
+     * 
+     * @param bgId 背景颜色ID
+     * @return 对应的背景资源ID
+     */
     protected abstract int getBgResourceId(int bgId);
 
+    /**
+     * 获取布局ID
+     * 
+     * 子类需要实现此方法以提供不同尺寸小部件的布局资源
+     * 
+     * @return 小部件布局资源ID
+     */
     protected abstract int getLayoutId();
 
+    /**
+     * 获取小部件类型
+     * 
+     * 子类需要实现此方法以提供小部件类型标识
+     * 
+     * @return 小部件类型常量
+     */
     protected abstract int getWidgetType();
 }

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NoteWidgetProvider_2x.java
+ * 描述: 2x尺寸便签小部件提供者实现类
+ * 作用: 提供2x尺寸的便签小部件功能，继承自NoteWidgetProvider基类
+ */
 package net.micode.notes.widget;
 
 import android.appwidget.AppWidgetManager;
@@ -23,23 +28,61 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 
-
+/**
+ * 2x尺寸便签小部件提供者类
+ * 
+ * 该类继承自NoteWidgetProvider，实现了2x尺寸便签小部件的具体功能。
+ * 2x尺寸是指Android桌面网格中占用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);
     }
 
+    /**
+     * 获取小部件布局资源ID
+     * 
+     * 实现父类的抽象方法，提供2x尺寸小部件的布局资源
+     * 
+     * @return 2x小部件布局资源ID
+     */
     @Override
     protected int getLayoutId() {
         return R.layout.widget_2x;
     }
 
+    /**
+     * 获取小部件背景资源ID
+     * 
+     * 实现父类的抽象方法，根据背景颜色ID获取对应的2x尺寸小部件背景资源
+     * 
+     * @param bgId 背景颜色ID
+     * @return 对应的2x小部件背景资源ID
+     */
     @Override
     protected int getBgResourceId(int bgId) {
+        // 使用ResourceParser工具类获取2x小部件的背景资源
         return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
     }
 
+    /**
+     * 获取小部件类型
+     * 
+     * 实现父类的抽象方法，提供2x小部件的类型标识
+     * 
+     * @return 2x小部件类型常量
+     */
     @Override
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_2X;

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

@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+/**
+ * 文件: NoteWidgetProvider_4x.java
+ * 描述: 4x尺寸便签小部件提供者实现类
+ * 作用: 提供4x尺寸的便签小部件功能，继承自NoteWidgetProvider基类
+ */
 package net.micode.notes.widget;
 
 import android.appwidget.AppWidgetManager;
@@ -23,22 +28,61 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
 
-
+/**
+ * 4x尺寸便签小部件提供者类
+ * 
+ * 该类继承自NoteWidgetProvider，实现了4x尺寸便签小部件的具体功能。
+ * 4x尺寸是指Android桌面网格中占用4x4个单元格的小部件，比2x尺寸更大，
+ * 可以显示更多的便签内容。
+ */
 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);
     }
 
+    /**
+     * 获取小部件布局资源ID
+     * 
+     * 实现父类的抽象方法，提供4x尺寸小部件的布局资源
+     * 
+     * @return 4x小部件布局资源ID
+     */
     protected int getLayoutId() {
         return R.layout.widget_4x;
     }
 
+    /**
+     * 获取小部件背景资源ID
+     * 
+     * 实现父类的抽象方法，根据背景颜色ID获取对应的4x尺寸小部件背景资源
+     * 
+     * @param bgId 背景颜色ID
+     * @return 对应的4x小部件背景资源ID
+     */
     @Override
     protected int getBgResourceId(int bgId) {
+        // 使用ResourceParser工具类获取4x小部件的背景资源
         return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
     }
 
+    /**
+     * 获取小部件类型
+     * 
+     * 实现父类的抽象方法，提供4x小部件的类型标识
+     * 
+     * @return 4x小部件类型常量
+     */
     @Override
     protected int getWidgetType() {
         return Notes.TYPE_WIDGET_4X;