From 1c2f888347aa1af72d1bebf443489f67a93916e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=B5=AE=E8=88=9F=E5=BD=93=E6=AD=8C?= <3240763365@qq.com>
Date: Sun, 15 Jun 2025 01:02:00 +0800
Subject: [PATCH] =?UTF-8?q?=E7=AC=AC=E4=BA=8C=E6=AC=A1=E6=8F=90=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .idea/gradle.xml                              |   1 +
 .idea/misc.xml                                |   1 -
 app/build.gradle.kts                          |   9 +-
 .../java/net/micode/notes/data/Contact.java   |  25 +
 .../java/net/micode/notes/data/Notes.java     | 258 ++++------
 .../notes/data/NotesDatabaseHelper.java       |  16 +-
 .../net/micode/notes/data/NotesProvider.java  | 463 +++++++++++-------
 .../net/micode/notes/gtask/data/MetaData.java |  38 +-
 .../java/net/micode/notes/model/Note.java     | 123 ++++-
 .../java/net/micode/notes/tool/DataUtils.java | 333 +++++++++----
 .../net/micode/notes/tool/ResourceParser.java |  32 +-
 .../net/micode/notes/ui/NoteEditActivity.java | 187 +++++--
 .../notes/widget/NoteWidgetProvider.java      | 119 +++--
 app/src/main/res/layout/note_edit.xml         | 131 +++++
 app/src/main/res/values-zh-rCN/strings.xml    |   9 +-
 app/src/main/res/values/strings.xml           |  13 +-
 16 files changed, 1208 insertions(+), 550 deletions(-)

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 97f0a8e..639c779 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 74dd639..b2c751a 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="jbr-21" project-jdk-type="JavaSDK">
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 87918a1..8c8d623 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -41,9 +41,12 @@ dependencies {
     implementation(libs.appcompat)
     implementation(libs.material)
     implementation(libs.constraintlayout)
-    implementation(files("D:\\Notesmaster2\\Notesmaster2\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-osgi-4.5.14.jar"))
-    implementation(files("D:\\Notesmaster2\\Notesmaster2\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-win-4.5.14.jar"))
-    implementation(files("D:\\Notesmaster2\\Notesmaster2\\httpcomponents-client-4.5.14-bin\\lib\\httpcore-4.4.16.jar"))
+    implementation(files("D:\\pull\\qw-notes\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-osgi-4.5.14.jar"))
+    implementation(files("D:\\pull\\qw-notes\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-win-4.5.14.jar"))
+    implementation(files("D:\\pull\\qw-notes\\httpcomponents-client-4.5.14-bin\\lib\\httpcore-4.4.16.jar"))
+    implementation(files("D:\\pull\\qw-notes\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-osgi-4.5.14.jar"))
+    implementation(files("D:\\pull\\qw-notes\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-win-4.5.14.jar"))
+    implementation(files("D:\\pull\\qw-notes\\httpcomponents-client-4.5.14-bin\\lib\\httpcore-4.4.16.jar"))
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.test.ext.junit)
     androidTestImplementation(libs.espresso.core)
diff --git a/app/src/main/java/net/micode/notes/data/Contact.java b/app/src/main/java/net/micode/notes/data/Contact.java
index d97ac5d..e60df20 100644
--- a/app/src/main/java/net/micode/notes/data/Contact.java
+++ b/app/src/main/java/net/micode/notes/data/Contact.java
@@ -25,10 +25,19 @@ import android.util.Log;
 
 import java.util.HashMap;
 
+/**
+ * Contact类用于管理联系人信息的缓存，提供高效的数据访问
+ */
 public class Contact {
+    // sContactCache用于缓存联系人信息，以提高访问速度
     private static HashMap<String, String> sContactCache;
+    // TAG用于日志记录，方便调试和追踪
     private static final String TAG = "Contact";
 
+    /**
+     * CALLER_ID_SELECTION定义了查询联系人时的SQL条件，用于精确匹配电话号码
+     * 这个条件确保了查询结果是基于电话号码精确匹配的，同时考虑了数据类型和原始联系人ID
+     */
     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 +45,32 @@ public class Contact {
             + " FROM phone_lookup"
             + " WHERE min_match = '+')";
 
+
+    /**
+     * 根据电话号码获取联系人名称
+     * 首先检查缓存中是否已有联系人名称，如果有则直接返回
+     * 如果没有，则查询系统联系人数据库，获取联系人名称并缓存
+     *
+     * @param context 上下文，用于访问系统内容解析器
+     * @param phoneNumber 电话号码，用于查询联系人
+     * @return 联系人名称，如果找不到则返回null
+     */
     public static String getContact(Context context, String phoneNumber) {
+        // 检查缓存对象是否为空，如果为空则初始化
         if(sContactCache == null) {
             sContactCache = new HashMap<String, String>();
         }
 
+        // 检查缓存中是否已有该电话号码对应的联系人名称
         if(sContactCache.containsKey(phoneNumber)) {
             return sContactCache.get(phoneNumber);
         }
 
+        // 准备查询条件，对电话号码进行处理以匹配呼叫者ID的最小长度
         String selection = CALLER_ID_SELECTION.replace("+",
                 PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+
+        // 执行查询，尝试从系统联系人数据库中获取联系人名称
         Cursor cursor = context.getContentResolver().query(
                 Data.CONTENT_URI,
                 new String [] { Phone.DISPLAY_NAME },
@@ -54,6 +78,7 @@ public class Contact {
                 new String[] { phoneNumber },
                 null);
 
+        // 处理查询结果，如果找到匹配的联系人则返回名称
         if (cursor != null && cursor.moveToFirst()) {
             try {
                 String name = cursor.getString(0);
diff --git a/app/src/main/java/net/micode/notes/data/Notes.java b/app/src/main/java/net/micode/notes/data/Notes.java
index f240604..eb35b0f 100644
--- a/app/src/main/java/net/micode/notes/data/Notes.java
+++ b/app/src/main/java/net/micode/notes/data/Notes.java
@@ -1,40 +1,55 @@
 /*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ * 版权所有 (c) 2010-2011, MiCode开源社区(www.micode.net)
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * 遵循Apache License 2.0开源协议
+ * 除非法律另有规定或书面同意，否则本软件按"原样"提供，无任何明示或暗示的担保
  */
 
+/**
+ * 笔记应用的核心数据定义类
+ * 包含笔记类型、文件夹结构、ContentProvider URI等全局常量
+ */
 package net.micode.notes.data;
 
 import android.net.Uri;
+
+/**
+ * 笔记应用的核心常量定义类
+ * 包含三大模块：
+ * 1. 基础常量定义
+ * 2. 数据库表结构定义
+ * 3. 内容提供器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;
 
     /**
-     * Following IDs are system folders' identifiers
-     * {@link Notes#ID_ROOT_FOLDER } is default folder
-     * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
-     * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
+     * 笔记类型常量：
+     * 0-普通笔记 1-文件夹 2-系统文件夹
+     */
+    public static final int TYPE_NOTE = 0;
+    public static final int TYPE_FOLDER = 1;
+    public static final int TYPE_SYSTEM = 2;
+
+    /**
+     * 系统文件夹ID定义：
+     * 0-根文件夹
+     * -1-临时文件夹（存放未分类笔记）
+     * -2-通话记录文件夹
+     * -3-回收站
      */
     public static final int ID_ROOT_FOLDER = 0;
     public static final int ID_TEMPARAY_FOLDER = -1;
     public static final int ID_CALL_RECORD_FOLDER = -2;
     public static final int ID_TRASH_FOLER = -3;
 
+    /**
+     * Intent传递参数的键值定义
+     */
     public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
     public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
     public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
@@ -42,238 +57,161 @@ public class Notes {
     public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
     public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
 
-    public static final int TYPE_WIDGET_INVALIDE      = -1;
-    public static final int TYPE_WIDGET_2X            = 0;
-    public static final int TYPE_WIDGET_4X            = 1;
+    /**
+     * 桌面小部件类型：
+     * -1-无效 0-2x尺寸 1-4x尺寸
+     */
+    public static final int TYPE_WIDGET_INVALIDE = -1;
+    public static final int TYPE_WIDGET_2X = 0;
+    public static final int TYPE_WIDGET_4X = 1;
 
+    /**
+     * 笔记数据类型常量
+     */
     public static class DataConstants {
+        /** 普通文本笔记类型 */
         public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
+        /** 通话记录笔记类型 */
         public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
     }
 
-    /**
-     * Uri to query all notes and folders
-     */
+    /** 查询所有笔记和文件夹的URI */
     public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
 
-    /**
-     * Uri to query data
-     */
+    /** 查询笔记数据的URI */
     public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
 
+    /**
+     * 笔记表字段定义接口
+     */
     public interface NoteColumns {
-        /**
-         * The unique ID for a row
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 主键ID */
         public static final String ID = "_id";
 
-        /**
-         * The parent's id for note or folder
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 父文件夹ID */
         public static final String PARENT_ID = "parent_id";
 
-        /**
-         * Created data for note or folder
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 创建时间戳 */
         public static final String CREATED_DATE = "created_date";
 
-        /**
-         * Latest modified date
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 最后修改时间 */
         public static final String MODIFIED_DATE = "modified_date";
 
-
-        /**
-         * Alert date
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 提醒时间 */
         public static final String ALERTED_DATE = "alert_date";
 
-        /**
-         * Folder's name or text content of note
-         * <P> Type: TEXT </P>
-         */
+        /** 内容摘要/文件夹名称 */
         public static final String SNIPPET = "snippet";
 
-        /**
-         * Note's widget id
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 关联的小部件ID */
         public static final String WIDGET_ID = "widget_id";
 
-        /**
-         * Note's widget type
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 小部件类型 */
         public static final String WIDGET_TYPE = "widget_type";
 
-        /**
-         * Note's background color's id
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 背景色ID */
         public static final String BG_COLOR_ID = "bg_color_id";
 
-        /**
-         * For text note, it doesn't has attachment, for multi-media
-         * note, it has at least one attachment
-         * <P> Type: INTEGER </P>
-         */
+        /** 是否有附件标记 */
         public static final String HAS_ATTACHMENT = "has_attachment";
 
-        /**
-         * Folder's count of notes
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 文件夹内的笔记数量 */
         public static final String NOTES_COUNT = "notes_count";
 
-        /**
-         * The file type: folder or note
-         * <P> Type: INTEGER </P>
-         */
+        /** 条目类型（笔记/文件夹） */
         public static final String TYPE = "type";
 
-        /**
-         * The last sync id
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 同步ID */
         public static final String SYNC_ID = "sync_id";
 
-        /**
-         * Sign to indicate local modified or not
-         * <P> Type: INTEGER </P>
-         */
+        /** 本地修改标记 */
         public static final String LOCAL_MODIFIED = "local_modified";
 
-        /**
-         * Original parent id before moving into temporary folder
-         * <P> Type : INTEGER </P>
-         */
+        /** 原始父ID（用于临时文件夹） */
         public static final String ORIGIN_PARENT_ID = "origin_parent_id";
 
-        /**
-         * The gtask id
-         * <P> Type : TEXT </P>
-         */
+        /** Google Tasks ID */
         public static final String GTASK_ID = "gtask_id";
 
-        /**
-         * The version code
-         * <P> Type : INTEGER (long) </P>
-         */
+        /** 版本号 */
         public static final String VERSION = "version";
     }
 
+    /**
+     * 笔记数据表字段定义接口
+     */
     public interface DataColumns {
-        /**
-         * The unique ID for a row
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 主键ID */
         public static final String ID = "_id";
 
-        /**
-         * The MIME type of the item represented by this row.
-         * <P> Type: Text </P>
-         */
+        /** MIME类型 */
         public static final String MIME_TYPE = "mime_type";
 
-        /**
-         * The reference id to note that this data belongs to
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 关联的笔记ID */
         public static final String NOTE_ID = "note_id";
 
-        /**
-         * Created data for note or folder
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 创建时间 */
         public static final String CREATED_DATE = "created_date";
 
-        /**
-         * Latest modified date
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 修改时间 */
         public static final String MODIFIED_DATE = "modified_date";
 
-        /**
-         * Data's content
-         * <P> Type: TEXT </P>
-         */
+        /** 内容数据 */
         public static final String CONTENT = "content";
 
-
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * integer data type
-         * <P> Type: INTEGER </P>
-         */
+        /** 扩展数据字段1（整数类型） */
         public static final String DATA1 = "data1";
 
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * integer data type
-         * <P> Type: INTEGER </P>
-         */
+        /** 扩展数据字段2（整数类型） */
         public static final String DATA2 = "data2";
 
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
-         */
+        /** 扩展数据字段3（文本类型） */
         public static final String DATA3 = "data3";
 
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
-         */
+        /** 扩展数据字段4（文本类型） */
         public static final String DATA4 = "data4";
 
-        /**
-         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
-         * TEXT data type
-         * <P> Type: TEXT </P>
-         */
+        /** 扩展数据字段5（文本类型） */
         public static final String DATA5 = "data5";
     }
 
+    /**
+     * 文本笔记专用常量
+     */
     public static final class TextNote implements DataColumns {
-        /**
-         * Mode to indicate the text in check list mode or not
-         * <P> Type: Integer 1:check list mode 0: normal mode </P>
-         */
+        /** 笔记模式：1-清单模式 0-普通模式 */
         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
-         * <P> Type: INTEGER (long) </P>
-         */
+        /** 通话日期（使用DATA1字段存储） */
         public static final String CALL_DATE = DATA1;
 
-        /**
-         * Phone number for this record
-         * <P> Type: TEXT </P>
-         */
+        /** 电话号码（使用DATA3字段存储） */
         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");
     }
 }
diff --git a/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java b/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java
index ffe5d57..af9fa62 100644
--- a/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java
+++ b/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java
@@ -27,19 +27,29 @@ 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;
 
     private static final String CREATE_NOTE_TABLE_SQL =
diff --git a/app/src/main/java/net/micode/notes/data/NotesProvider.java b/app/src/main/java/net/micode/notes/data/NotesProvider.java
index edb0a60..5b2ccf6 100644
--- a/app/src/main/java/net/micode/notes/data/NotesProvider.java
+++ b/app/src/main/java/net/micode/notes/data/NotesProvider.java
@@ -85,217 +85,312 @@ public class NotesProvider extends ContentProvider {
         return true;
     }
 
-    @Override
-    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
-            String sortOrder) {
-        Cursor c = null;
-        SQLiteDatabase db = mHelper.getReadableDatabase();
-        String id = null;
-        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");
-                }
+    /**
+ * 查询数据库并返回Cursor对象。
+ * 根据不同的URI匹配类型执行不同的查询操作，包括普通查询、ID查询和搜索查询。
+ *
+ * @param uri 用于确定查询类型的URI
+ * @param projection 要返回的列名数组，null表示返回所有列
+ * @param selection WHERE条件子句，不包括WHERE关键字，null表示无条件
+ * @param selectionArgs 用于替换selection中的"?"占位符的参数数组
+ * @param sortOrder 排序方式，null表示默认排序
+ * @return 包含查询结果的Cursor对象，可能为null
+ * @throws IllegalArgumentException 如果URI未知或搜索查询中指定了不允许的参数
+ */
+@Override
+public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+        String sortOrder) {
+    Cursor c = null;
+    SQLiteDatabase db = mHelper.getReadableDatabase();
+    String id = null;
 
-                String searchString = null;
-                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
-                    if (uri.getPathSegments().size() > 1) {
-                        searchString = uri.getPathSegments().get(1);
-                    }
-                } else {
-                    searchString = uri.getQueryParameter("pattern");
-                }
+    // 根据URI匹配类型执行不同的查询逻辑
+    switch (mMatcher.match(uri)) {
+        case URI_NOTE:
+            // 查询整个NOTE表
+            c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
+                    sortOrder);
+            break;
+        case URI_NOTE_ITEM:
+            // 查询NOTE表中指定ID的记录
+            id = uri.getPathSegments().get(1);
+            c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+                    + parseSelection(selection), selectionArgs, null, null, sortOrder);
+            break;
+        case URI_DATA:
+            // 查询整个DATA表
+            c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
+                    sortOrder);
+            break;
+        case URI_DATA_ITEM:
+            // 查询DATA表中指定ID的记录
+            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");
+            }
 
-                if (TextUtils.isEmpty(searchString)) {
-                    return null;
+            // 获取搜索字符串
+            String searchString = null;
+            if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
+                if (uri.getPathSegments().size() > 1) {
+                    searchString = uri.getPathSegments().get(1);
                 }
+            } else {
+                searchString = uri.getQueryParameter("pattern");
+            }
 
-                try {
-                    searchString = String.format("%%%s%%", searchString);
-                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
-                            new String[] { searchString });
-                } catch (IllegalStateException ex) {
-                    Log.e(TAG, "got exception: " + ex.toString());
-                }
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown URI " + uri);
-        }
-        if (c != null) {
-            c.setNotificationUri(getContext().getContentResolver(), uri);
-        }
-        return c;
+            if (TextUtils.isEmpty(searchString)) {
+                return null;
+            }
+
+            try {
+                // 执行模糊搜索查询
+                searchString = String.format("%%%s%%", searchString);
+                c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
+                        new String[] { searchString });
+            } catch (IllegalStateException ex) {
+                Log.e(TAG, "got exception: " + ex.toString());
+            }
+            break;
+        default:
+            throw new IllegalArgumentException("Unknown URI " + uri);
     }
 
-    @Override
-    public Uri insert(Uri uri, ContentValues values) {
-        SQLiteDatabase db = mHelper.getWritableDatabase();
-        long dataId = 0, noteId = 0, insertedId = 0;
-        switch (mMatcher.match(uri)) {
-            case URI_NOTE:
-                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 {
-                    Log.d(TAG, "Wrong data format without note id:" + values.toString());
-                }
-                insertedId = dataId = db.insert(TABLE.DATA, null, values);
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown URI " + uri);
-        }
-        // Notify the note uri
-        if (noteId > 0) {
-            getContext().getContentResolver().notifyChange(
-                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
-        }
+    // 设置Cursor的通知URI，以便内容变化时能自动更新
+    if (c != null) {
+        c.setNotificationUri(getContext().getContentResolver(), uri);
+    }
+    return c;
+}
 
-        // Notify the data uri
-        if (dataId > 0) {
-            getContext().getContentResolver().notifyChange(
-                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
-        }
 
-        return ContentUris.withAppendedId(uri, insertedId);
+    /**
+ * 插入数据到数据库并返回对应的URI
+ *
+ * 该方法根据传入的URI类型决定将数据插入到不同的表中，并通知相关URI的数据变更
+ *
+ * @param uri 要插入数据的URI，用于确定目标表类型
+ * @param values 要插入的数据键值对
+ * @return 新插入数据的URI，包含新记录的ID
+ * @throws IllegalArgumentException 如果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:
+            // 插入笔记数据并获取新记录的ID
+            insertedId = noteId = db.insert(TABLE.NOTE, null, values);
+            break;
+        case URI_DATA:
+            // 检查并获取关联的笔记ID
+            if (values.containsKey(DataColumns.NOTE_ID)) {
+                noteId = values.getAsLong(DataColumns.NOTE_ID);
+            } else {
+                Log.d(TAG, "Wrong data format without note id:" + values.toString());
+            }
+            // 插入数据记录并获取新记录的ID
+            insertedId = dataId = db.insert(TABLE.DATA, null, values);
+            break;
+        default:
+            throw new IllegalArgumentException("Unknown URI " + uri);
     }
 
-    @Override
-    public int delete(Uri uri, String selection, String[] selectionArgs) {
-        int count = 0;
-        String id = null;
-        SQLiteDatabase db = mHelper.getWritableDatabase();
-        boolean deleteData = false;
-        switch (mMatcher.match(uri)) {
-            case URI_NOTE:
-                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
-                 * trash
-                 */
-                long noteId = Long.valueOf(id);
-                if (noteId <= 0) {
-                    break;
-                }
-                count = db.delete(TABLE.NOTE,
-                        NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
-                break;
-            case URI_DATA:
-                count = db.delete(TABLE.DATA, selection, selectionArgs);
-                deleteData = true;
-                break;
-            case URI_DATA_ITEM:
-                id = uri.getPathSegments().get(1);
-                count = db.delete(TABLE.DATA,
-                        DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
-                deleteData = true;
+    // 如果插入的是笔记或关联笔记的数据，通知笔记URI的数据变更
+    if (noteId > 0) {
+        getContext().getContentResolver().notifyChange(
+                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
+    }
+
+    // 如果插入的是数据记录，通知数据URI的数据变更
+    if (dataId > 0) {
+        getContext().getContentResolver().notifyChange(
+                ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
+    }
+
+    // 返回新插入记录的完整URI
+    return ContentUris.withAppendedId(uri, insertedId);
+}
+
+
+    /**
+ * 删除数据库中与给定URI匹配的记录
+ *
+ * @param uri 内容URI，用于确定要删除的数据类型和具体条目
+ * @param selection 可选的选择条件，用于筛选要删除的记录，格式为SQL WHERE子句（不包含WHERE关键字）
+ * @param selectionArgs 选择条件的参数值，将替换selection中的"?"占位符
+ * @return int 被删除的记录数量
+ */
+@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的记录（系统文件夹不允许删除）
+            selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
+            count = db.delete(TABLE.NOTE, selection, selectionArgs);
+            break;
+        case URI_NOTE_ITEM:
+            // 删除单个笔记项，同样需要检查是否为系统文件夹
+            id = uri.getPathSegments().get(1);
+            long noteId = Long.valueOf(id);
+            if (noteId <= 0) {
                 break;
-            default:
-                throw new IllegalArgumentException("Unknown URI " + uri);
-        }
-        if (count > 0) {
-            if (deleteData) {
-                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
             }
-            getContext().getContentResolver().notifyChange(uri, null);
-        }
-        return count;
+            count = db.delete(TABLE.NOTE,
+                    NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+            break;
+        case URI_DATA:
+            // 删除数据记录，并标记需要通知笔记URI变更
+            count = db.delete(TABLE.DATA, selection, selectionArgs);
+            deleteData = true;
+            break;
+        case URI_DATA_ITEM:
+            // 删除单个数据项，并标记需要通知笔记URI变更
+            id = uri.getPathSegments().get(1);
+            count = db.delete(TABLE.DATA,
+                    DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+            deleteData = true;
+            break;
+        default:
+            throw new IllegalArgumentException("Unknown URI " + uri);
     }
 
-    @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;
-        switch (mMatcher.match(uri)) {
-            case URI_NOTE:
-                increaseNoteVersion(-1, selection, selectionArgs);
-                count = db.update(TABLE.NOTE, values, selection, selectionArgs);
-                break;
-            case URI_NOTE_ITEM:
-                id = uri.getPathSegments().get(1);
-                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);
-                updateData = true;
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown URI " + uri);
+    // 如果有记录被删除，通知内容观察者更新
+    if (count > 0) {
+        if (deleteData) {
+            // 数据删除时需要额外通知笔记URI变更
+            getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
         }
+        getContext().getContentResolver().notifyChange(uri, null);
+    }
+    return count;
+}
 
-        if (count > 0) {
-            if (updateData) {
-                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
-            }
-            getContext().getContentResolver().notifyChange(uri, null);
+
+    /**
+ * 更新数据库中的记录
+ *
+ * @param uri 内容URI，用于确定要操作的数据表和记录
+ * @param values 包含要更新的字段名和值的ContentValues对象
+ * @param selection WHERE子句的条件，可以为null
+ * @param selectionArgs WHERE子句的条件参数，可以为null
+ * @return 被更新的记录数量
+ * @throws IllegalArgumentException 如果URI无法识别则抛出此异常
+ */
+@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);
+            count = db.update(TABLE.NOTE, values, selection, selectionArgs);
+            break;
+        case URI_NOTE_ITEM:
+            // 更新笔记表的单条记录，并增加版本号
+            id = uri.getPathSegments().get(1);
+            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);
+            updateData = true;
+            break;
+        default:
+            throw new IllegalArgumentException("Unknown URI " + uri);
+    }
+
+    // 如果有记录被更新，则通知内容观察者
+    if (count > 0) {
+        if (updateData) {
+            // 更新数据表时需要额外通知笔记URI的变化
+            getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
         }
-        return count;
+        getContext().getContentResolver().notifyChange(uri, null);
     }
+    return count;
+}
+
 
     private String parseSelection(String selection) {
         return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
     }
 
-    private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
-        StringBuilder sql = new StringBuilder(120);
-        sql.append("UPDATE ");
-        sql.append(TABLE.NOTE);
-        sql.append(" SET ");
-        sql.append(NoteColumns.VERSION);
-        sql.append("=" + NoteColumns.VERSION + "+1 ");
+    /**
+ * 增加笔记的版本号
+ *
+ * 该方法构建并执行一个SQL UPDATE语句，将指定笔记的版本号(VERSION)加1。
+ * 可以通过ID或选择条件来指定要更新的笔记记录。
+ *
+ * @param id 要更新的笔记ID，如果id <= 0则表示不使用ID作为条件
+ * @param selection 原始SQL WHERE条件(不含WHERE关键字)，可包含?占位符
+ * @param selectionArgs 用于替换selection中?占位符的参数值数组
+ */
+private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+    // 构建基础UPDATE语句，设置版本号+1
+    StringBuilder sql = new StringBuilder(120);
+    sql.append("UPDATE ");
+    sql.append(TABLE.NOTE);
+    sql.append(" SET ");
+    sql.append(NoteColumns.VERSION);
+    sql.append("=" + NoteColumns.VERSION + "+1 ");
 
-        if (id > 0 || !TextUtils.isEmpty(selection)) {
-            sql.append(" WHERE ");
-        }
-        if (id > 0) {
-            sql.append(NoteColumns.ID + "=" + String.valueOf(id));
-        }
-        if (!TextUtils.isEmpty(selection)) {
-            String selectString = id > 0 ? parseSelection(selection) : selection;
-            for (String args : selectionArgs) {
-                selectString = selectString.replaceFirst("\\?", args);
-            }
-            sql.append(selectString);
-        }
+    // 处理WHERE条件
+    if (id > 0 || !TextUtils.isEmpty(selection)) {
+        sql.append(" WHERE ");
+    }
+
+    // 添加ID条件(如果id有效)
+    if (id > 0) {
+        sql.append(NoteColumns.ID + "=" + String.valueOf(id));
+    }
 
-        mHelper.getWritableDatabase().execSQL(sql.toString());
+    // 处理selection条件(如果存在)
+    if (!TextUtils.isEmpty(selection)) {
+        String selectString = id > 0 ? parseSelection(selection) : selection;
+        // 替换selection中的占位符
+        for (String args : selectionArgs) {
+            selectString = selectString.replaceFirst("\\?", args);
+        }
+        sql.append(selectString);
     }
 
+    // 执行SQL语句
+    mHelper.getWritableDatabase().execSQL(sql.toString());
+}
+
+
     @Override
     public String getType(Uri uri) {
         // TODO Auto-generated method stub
diff --git a/app/src/main/java/net/micode/notes/gtask/data/MetaData.java b/app/src/main/java/net/micode/notes/gtask/data/MetaData.java
index 3a2050b..d24ea67 100644
--- a/app/src/main/java/net/micode/notes/gtask/data/MetaData.java
+++ b/app/src/main/java/net/micode/notes/gtask/data/MetaData.java
@@ -25,11 +25,19 @@ import org.json.JSONException;
 import org.json.JSONObject;
 
 
+/**
+ * 元数据类，继承自Task类，用于处理与任务相关的元数据信息
+ */
 public class MetaData extends Task {
     private final static String TAG = MetaData.class.getSimpleName();
 
     private String mRelatedGid = null;
 
+    /**
+     * 设置元数据信息
+     * @param gid 关联的GTask ID
+     * @param metaInfo 包含元数据的JSON对象
+     */
     public void setMeta(String gid, JSONObject metaInfo) {
         try {
             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
@@ -40,20 +48,33 @@ public class MetaData extends Task {
         setName(GTaskStringUtils.META_NOTE_NAME);
     }
 
+    /**
+     * 获取关联的GTask ID
+     * @return 关联的GTask ID字符串
+     */
     public String getRelatedGid() {
         return mRelatedGid;
     }
 
+    /**
+     * 判断当前元数据是否值得保存
+     * @return 如果notes字段不为null则返回true，否则返回false
+     */
     @Override
     public boolean isWorthSaving() {
         return getNotes() != null;
     }
 
+    /**
+     * 从远程JSON对象设置内容
+     * @param js 包含远程数据的JSON对象
+     */
     @Override
     public void setContentByRemoteJSON(JSONObject js) {
         super.setContentByRemoteJSON(js);
         if (getNotes() != null) {
             try {
+                // 解析notes字段中的JSON数据获取关联GTask ID
                 JSONObject metaInfo = new JSONObject(getNotes().trim());
                 mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
             } catch (JSONException e) {
@@ -63,17 +84,32 @@ 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 无返回值
+     * @throws IllegalAccessError 总是抛出该异常，表示不支持此操作
+     */
     @Override
     public JSONObject getLocalJSONFromContent() {
         throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
     }
 
+    /**
+     * 获取同步动作（不支持该操作）
+     * @param c 数据库游标
+     * @return 无返回值
+     * @throws IllegalAccessError 总是抛出该异常，表示不支持此操作
+     */
     @Override
     public int getSyncAction(Cursor c) {
         throw new IllegalAccessError("MetaData:getSyncAction should not be called");
diff --git a/app/src/main/java/net/micode/notes/model/Note.java b/app/src/main/java/net/micode/notes/model/Note.java
index 6706cf6..a23ad47 100644
--- a/app/src/main/java/net/micode/notes/model/Note.java
+++ b/app/src/main/java/net/micode/notes/model/Note.java
@@ -34,15 +34,23 @@ 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，创建失败返回0
+     * @throws IllegalStateException 如果返回的noteId为-1时抛出异常
      */
     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 +58,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));
@@ -65,63 +76,101 @@ public class Note {
         return noteId;
     }
 
+    /**
+     * 构造函数，初始化笔记数据和差异值容器
+     */
     public Note() {
         mNoteDiffValues = new ContentValues();
         mNoteData = new NoteData();
     }
 
+    /**
+     * 设置笔记属性值
+     * @param key 属性键
+     * @param value 属性值
+     */
     public void setNoteValue(String key, String value) {
         mNoteDiffValues.put(key, value);
         mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
         mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
     }
 
+    /**
+     * 设置文本数据
+     * @param key 数据键
+     * @param value 数据值
+     */
     public void setTextData(String key, String value) {
         mNoteData.setTextData(key, value);
     }
 
+    /**
+     * 设置文本数据ID
+     * @param id 文本数据ID
+     */
     public void setTextDataId(long id) {
         mNoteData.setTextDataId(id);
     }
 
+    /**
+     * 获取文本数据ID
+     * @return 文本数据ID
+     */
     public long getTextDataId() {
         return mNoteData.mTextDataId;
     }
 
+    /**
+     * 设置通话数据ID
+     * @param id 通话数据ID
+     */
     public void setCallDataId(long id) {
         mNoteData.setCallDataId(id);
     }
 
+    /**
+     * 设置通话数据
+     * @param key 数据键
+     * @param value 数据值
+     */
     public void setCallData(String key, String value) {
         mNoteData.setCallData(key, value);
     }
 
+    /**
+     * 检查笔记是否有本地修改
+     * @return true表示有本地修改，false表示无修改
+     */
     public boolean isLocalModified() {
         return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
     }
 
+    /**
+     * 同步笔记数据到内容提供器
+     * @param context 上下文对象
+     * @param noteId 笔记ID
+     * @return true表示同步成功，false表示失败
+     * @throws IllegalArgumentException 如果noteId<=0时抛出
+     */
     public boolean syncNote(Context context, long noteId) {
         if (noteId <= 0) {
             throw new IllegalArgumentException("Wrong note id:" + noteId);
         }
 
+        // 无修改则直接返回成功
         if (!isLocalModified()) {
             return true;
         }
 
-        /**
-         * In theory, once data changed, the note should be updated on {@link NoteColumns#LOCAL_MODIFIED} and
-         * {@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) {
             Log.e(TAG, "Update note error, should not happen");
-            // Do not return, fall through
         }
         mNoteDiffValues.clear();
 
+        // 更新笔记内容数据
         if (mNoteData.isLocalModified()
                 && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
             return false;
@@ -130,17 +179,19 @@ public class Note {
         return true;
     }
 
+    /**
+     * 笔记数据内部类，管理文本和通话数据
+     */
     private class NoteData {
         private long mTextDataId;
-
         private ContentValues mTextDataValues;
-
         private long mCallDataId;
-
         private ContentValues mCallDataValues;
-
         private static final String TAG = "NoteData";
 
+        /**
+         * 构造函数，初始化数据容器
+         */
         public NoteData() {
             mTextDataValues = new ContentValues();
             mCallDataValues = new ContentValues();
@@ -148,10 +199,19 @@ public class Note {
             mCallDataId = 0;
         }
 
+        /**
+         * 检查数据是否有本地修改
+         * @return true表示有修改，false表示无修改
+         */
         boolean isLocalModified() {
             return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
         }
 
+        /**
+         * 设置文本数据ID
+         * @param id 文本数据ID
+         * @throws IllegalArgumentException 如果id<=0时抛出
+         */
         void setTextDataId(long id) {
             if(id <= 0) {
                 throw new IllegalArgumentException("Text data id should larger than 0");
@@ -159,6 +219,11 @@ public class Note {
             mTextDataId = id;
         }
 
+        /**
+         * 设置通话数据ID
+         * @param id 通话数据ID
+         * @throws IllegalArgumentException 如果id<=0时抛出
+         */
         void setCallDataId(long id) {
             if (id <= 0) {
                 throw new IllegalArgumentException("Call data id should larger than 0");
@@ -166,32 +231,48 @@ public class Note {
             mCallDataId = id;
         }
 
+        /**
+         * 设置通话数据
+         * @param key 数据键
+         * @param value 数据值
+         */
         void setCallData(String key, String value) {
             mCallDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
+        /**
+         * 设置文本数据
+         * @param key 数据键
+         * @param value 数据值
+         */
         void setTextData(String key, String value) {
             mTextDataValues.put(key, value);
             mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
             mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
         }
 
+        /**
+         * 将数据推送到内容提供器
+         * @param context 上下文对象
+         * @param noteId 笔记ID
+         * @return 操作成功返回URI，失败返回null
+         * @throws IllegalArgumentException 如果noteId<=0时抛出
+         */
         Uri pushIntoContentResolver(Context context, long noteId) {
-            /**
-             * Check for safety
-             */
             if (noteId <= 0) {
                 throw new IllegalArgumentException("Wrong note id:" + noteId);
             }
 
-            ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+            ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
             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 +284,7 @@ public class Note {
                         return null;
                     }
                 } else {
+                    // 已有文本数据则更新
                     builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mTextDataId));
                     builder.withValues(mTextDataValues);
@@ -211,9 +293,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 +309,7 @@ public class Note {
                         return null;
                     }
                 } else {
+                    // 已有通话数据则更新
                     builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mCallDataId));
                     builder.withValues(mCallDataValues);
@@ -233,16 +318,14 @@ public class Note {
                 mCallDataValues.clear();
             }
 
+            // 批量执行操作
             if (operationList.size() > 0) {
                 try {
                     ContentProviderResult[] results = context.getContentResolver().applyBatch(
                             Notes.AUTHORITY, operationList);
                     return (results == null || results.length == 0 || results[0] == null) ? null
                             : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
-                } catch (RemoteException e) {
-                    Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
-                    return null;
-                } catch (OperationApplicationException e) {
+                } catch (RemoteException | OperationApplicationException e) {
                     Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
                     return null;
                 }
diff --git a/app/src/main/java/net/micode/notes/tool/DataUtils.java b/app/src/main/java/net/micode/notes/tool/DataUtils.java
index 2a14982..30aaca3 100644
--- a/app/src/main/java/net/micode/notes/tool/DataUtils.java
+++ b/app/src/main/java/net/micode/notes/tool/DataUtils.java
@@ -37,106 +37,160 @@ import java.util.HashSet;
 
 public class DataUtils {
     public static final String TAG = "DataUtils";
-    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
-        if (ids == null) {
-            Log.d(TAG, "the ids is null");
-            return true;
-        }
-        if (ids.size() == 0) {
-            Log.d(TAG, "no id is in the hashset");
-            return true;
-        }
+    /**
+ * 批量删除笔记
+ *
+ * @param resolver ContentResolver对象，用于执行内容提供者操作
+ * @param ids 要删除的笔记ID集合，如果为null或空集合则直接返回成功
+ * @return boolean 删除结果：true表示全部删除成功(或无需删除)，false表示删除失败
+ */
+public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+    // 处理空参数情况
+    if (ids == null) {
+        Log.d(TAG, "the ids is null");
+        return true;
+    }
+    if (ids.size() == 0) {
+        Log.d(TAG, "no id is in the hashset");
+        return true;
+    }
 
-        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
-        for (long id : ids) {
-            if(id == Notes.ID_ROOT_FOLDER) {
-                Log.e(TAG, "Don't delete system folder root");
-                continue;
-            }
-            ContentProviderOperation.Builder builder = ContentProviderOperation
-                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
-            operationList.add(builder.build());
+    // 构建批量删除操作列表
+    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;
         }
-        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;
+        ContentProviderOperation.Builder builder = ContentProviderOperation
+                .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+        operationList.add(builder.build());
     }
 
-    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.ORIGIN_PARENT_ID, srcFolderId);
-        values.put(NoteColumns.LOCAL_MODIFIED, 1);
-        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
+    // 执行批量删除操作
+    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;
+}
 
-    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) {
-            ContentProviderOperation.Builder builder = ContentProviderOperation
-                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
-            builder.withValue(NoteColumns.PARENT_ID, folderId);
-            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
-            operationList.add(builder.build());
-        }
+    /**
+ * 将指定笔记从源文件夹移动到目标文件夹
+ *
+ * @param resolver ContentResolver对象，用于执行内容提供者操作
+ * @param id 要移动的笔记ID
+ * @param srcFolderId 源文件夹ID，笔记当前所在的文件夹
+ * @param desFolderId 目标文件夹ID，笔记将要移动到的文件夹
+ */
+public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+    // 创建ContentValues对象并设置笔记的新位置和修改状态
+    ContentValues values = new ContentValues();
+    values.put(NoteColumns.PARENT_ID, desFolderId);
+    values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
+    values.put(NoteColumns.LOCAL_MODIFIED, 1);
 
-        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()));
+    // 更新笔记在数据库中的位置信息
+    resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
+}
+
+
+    /**
+ * 批量将笔记移动到指定文件夹
+ *
+ * @param resolver ContentResolver对象，用于执行内容提供者操作
+ * @param ids 要移动的笔记ID集合，如果为null则视为成功(不执行任何操作)
+ * @param folderId 目标文件夹ID
+ * @return true表示操作成功，false表示操作失败
+ */
+public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
+        long folderId) {
+    // 处理空ID集合的特殊情况
+    if (ids == null) {
+        Log.d(TAG, "the ids is null");
+        return true;
+    }
+
+    // 构建批量更新操作列表
+    ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+    for (long id : ids) {
+        ContentProviderOperation.Builder builder = ContentProviderOperation
+                .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+        builder.withValue(NoteColumns.PARENT_ID, folderId);
+        builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
+        operationList.add(builder.build());
+    }
+
+    // 执行批量操作并处理结果
+    try {
+        ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+        if (results == null || results.length == 0 || results[0] == null) {
+            Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+            return false;
         }
-        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}}
      */
+    // 定义一个静态方法，用于获取用户文件夹数量
     public static int getUserFolderCount(ContentResolver resolver) {
-        Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
-                new String[] { "COUNT(*)" },
-                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
-                new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
-                null);
+        // 查询数据库，获取符合条件的记录数量
+        Cursor cursor = resolver.query(
+                Notes.CONTENT_NOTE_URI,            // 要查询的URI（内容提供者的地址）
+                new String[] { "COUNT(*)" },       // 要返回的列，这里只返回计数结果
+                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?", // 查询条件：类型为文件夹且不在回收站中
+                new String[] {                     // 查询条件的参数值
+                        String.valueOf(Notes.TYPE_FOLDER),      // 类型为文件夹
+                        String.valueOf(Notes.ID_TRASH_FOLER)    // 排除回收站中的文件夹
+                },
+                null                                // 排序方式，这里不需要排序
+        );
 
-        int count = 0;
-        if(cursor != null) {
-            if(cursor.moveToFirst()) {
+        int count = 0;  // 初始化计数器为0
+        if(cursor != null) {  // 检查Cursor对象是否有效
+            if(cursor.moveToFirst()) {  // 将游标移动到第一条记录
                 try {
-                    count = cursor.getInt(0);
+                    count = cursor.getInt(0);  // 获取第一列的值（即COUNT(*)的结果）
                 } catch (IndexOutOfBoundsException e) {
+                    // 如果发生数组越界异常，记录错误日志
                     Log.e(TAG, "get folder count failed:" + e.toString());
                 } finally {
-                    cursor.close();
+                    cursor.close();  // 无论是否发生异常，都要关闭游标
                 }
             }
         }
-        return count;
+        return count;  // 返回文件夹数量
     }
 
+    /**
+     * 检查指定类型的笔记是否存在于笔记数据库中（不包括回收站中的笔记）
+     *
+     * @param resolver ContentResolver对象，用于执行内容提供者查询
+     * @param noteId 要查询的笔记ID
+     * @param type 要匹配的笔记类型
+     * @return boolean 如果存在符合条件的笔记则返回true，否则返回false
+     */
     public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+        // 查询条件：匹配指定笔记ID、指定类型，且父ID不等于回收站文件夹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 +199,7 @@ public class DataUtils {
 
         boolean exist = false;
         if (cursor != null) {
+            // 如果查询结果包含记录，则标记为存在
             if (cursor.getCount() > 0) {
                 exist = true;
             }
@@ -153,12 +208,21 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查指定ID的笔记是否存在于笔记数据库中
+     *
+     * @param resolver 内容解析器，用于查询内容提供者
+     * @param noteId 要检查的笔记ID
+     * @return boolean 如果笔记存在返回true，否则返回false
+     */
     public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+        // 构建URI并查询指定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 +231,21 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查指定ID的数据是否存在于数据数据库中
+     *
+     * @param resolver ContentResolver对象，用于执行内容提供者查询
+     * @param dataId   要查询的数据记录的ID
+     * @return boolean 返回true表示数据存在，false表示不存在或查询失败
+     */
     public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+        // 构建URI并查询指定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,13 +254,24 @@ public class DataUtils {
         return exist;
     }
 
+    /**
+     * 检查指定名称的文件夹是否已存在（非回收站中的文件夹）
+     *
+     * @param resolver ContentResolver对象，用于查询内容提供者数据
+     * @param name 要检查的文件夹名称
+     * @return boolean - 如果存在同名文件夹返回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,42 +281,63 @@ public class DataUtils {
         return exist;
     }
 
-    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
-        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
-                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
-                NoteColumns.PARENT_ID + "=?",
-                new String[] { String.valueOf(folderId) },
-                null);
+    /**
+ * 获取指定文件夹中所有笔记小部件的属性集合
+ *
+ * @param resolver ContentResolver对象，用于查询内容提供者数据
+ * @param folderId 要查询的文件夹ID
+ * @return HashSet<AppWidgetAttribute> 包含所有笔记小部件属性的集合，如果没有则返回null
+ */
+public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+    // 查询指定文件夹下的所有笔记小部件数据
+    Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
+            new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
+            NoteColumns.PARENT_ID + "=?",
+            new String[] { String.valueOf(folderId) },
+            null);
 
-        HashSet<AppWidgetAttribute> set = null;
-        if (c != null) {
-            if (c.moveToFirst()) {
-                set = new HashSet<AppWidgetAttribute>();
-                do {
-                    try {
-                        AppWidgetAttribute widget = new AppWidgetAttribute();
-                        widget.widgetId = c.getInt(0);
-                        widget.widgetType = c.getInt(1);
-                        set.add(widget);
-                    } catch (IndexOutOfBoundsException e) {
-                        Log.e(TAG, e.toString());
-                    }
-                } while (c.moveToNext());
-            }
-            c.close();
+    HashSet<AppWidgetAttribute> set = null;
+    if (c != null) {
+        // 如果查询结果不为空，则遍历Cursor构建小部件属性集合
+        if (c.moveToFirst()) {
+            set = new HashSet<AppWidgetAttribute>();
+            do {
+                try {
+                    // 从Cursor中读取小部件数据并创建属性对象
+                    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());
         }
-        return set;
+        c.close();
     }
+    return set;
+}
+
 
+    /**
+     * 根据笔记ID获取对应的电话号码
+     *
+     * @param resolver ContentResolver对象，用于查询内容提供者数据
+     * @param noteId 要查询的笔记ID
+     * @return 返回查询到的电话号码字符串，如果查询失败或不存在则返回空字符串
+     */
     public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+        // 查询条件：指定noteId和mime类型为CallNote类型的数据
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.PHONE_NUMBER },
                 CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
                 new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
                 null);
 
+        // 处理查询结果
         if (cursor != null && cursor.moveToFirst()) {
             try {
+                // 返回第一行第一列的电话号码
                 return cursor.getString(0);
             } catch (IndexOutOfBoundsException e) {
                 Log.e(TAG, "Get call number fails " + e.toString());
@@ -243,7 +348,16 @@ public class DataUtils {
         return "";
     }
 
+    /**
+     * 根据电话号码和通话日期获取对应的便签ID
+     *
+     * @param resolver ContentResolver对象，用于访问内容提供者
+     * @param phoneNumber 电话号码，用于查询匹配的便签记录
+     * @param callDate 通话日期时间戳，用于查询指定日期的便签记录
+     * @return 匹配的便签ID，如果未找到则返回0
+     */
     public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+        // 查询条件：通话日期、MIME类型和电话号码（使用PHONE_NUMBERS_EQUAL函数比较）
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                 new String [] { CallNote.NOTE_ID },
                 CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
@@ -251,9 +365,11 @@ public class DataUtils {
                 new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
                 null);
 
+        // 处理查询结果
         if (cursor != null) {
             if (cursor.moveToFirst()) {
                 try {
+                    // 返回第一条记录的NOTE_ID
                     return cursor.getLong(0);
                 } catch (IndexOutOfBoundsException e) {
                     Log.e(TAG, "Get call note id fails " + e.toString());
@@ -264,7 +380,16 @@ public class DataUtils {
         return 0;
     }
 
+    /**
+     * 根据笔记ID获取对应的内容片段(摘要)
+     *
+     * @param resolver ContentResolver对象，用于执行内容提供者查询
+     * @param noteId 要查询的笔记的唯一ID
+     * @return 返回查询到的笔记内容片段(摘要)，如果未找到则返回空字符串
+     * @throws IllegalArgumentException 如果未找到对应ID的笔记时抛出
+     */
     public static String getSnippetById(ContentResolver resolver, long noteId) {
+        // 查询指定ID的笔记片段
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
                 new String [] { NoteColumns.SNIPPET },
                 NoteColumns.ID + "=?",
@@ -273,6 +398,7 @@ public class DataUtils {
 
         if (cursor != null) {
             String snippet = "";
+            // 如果查询到结果，获取第一条记录的片段内容
             if (cursor.moveToFirst()) {
                 snippet = cursor.getString(0);
             }
@@ -282,9 +408,22 @@ public class DataUtils {
         throw new IllegalArgumentException("Note is not found with id: " + noteId);
     }
 
+    /**
+     * 获取格式化后的代码片段
+     *
+     * 该方法用于处理原始代码片段，主要完成以下操作：
+     * 1. 去除首尾空白字符
+     * 2. 截取第一个换行符之前的内容（如果存在换行符）
+     *
+     * @param snippet 原始代码片段，可能为null
+     * @return 格式化后的代码片段，可能为null（当输入为null时）或单行字符串
+     */
     public static String getFormattedSnippet(String snippet) {
         if (snippet != null) {
+            // 去除首尾空白字符
             snippet = snippet.trim();
+
+            // 查找第一个换行符位置并截取
             int index = snippet.indexOf('\n');
             if (index != -1) {
                 snippet = snippet.substring(0, index);
diff --git a/app/src/main/java/net/micode/notes/tool/ResourceParser.java b/app/src/main/java/net/micode/notes/tool/ResourceParser.java
index 1ad3ad6..9764c2b 100644
--- a/app/src/main/java/net/micode/notes/tool/ResourceParser.java
+++ b/app/src/main/java/net/micode/notes/tool/ResourceParser.java
@@ -39,8 +39,17 @@ public class ResourceParser {
 
     public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
 
+    // Font colors
+    public static final int FONT_COLOR_BLACK     = 0;
+    public static final int FONT_COLOR_RED       = 1;
+    public static final int FONT_COLOR_BLUE      = 2;
+    public static final int FONT_COLOR_GREEN     = 3;
+    public static final int FONT_COLOR_WHITE     = 4;
+
+    public static final int DEFAULT_FONT_COLOR   = FONT_COLOR_BLACK;
+
     public static class NoteBgResources {
-        private final static int [] BG_EDIT_RESOURCES = new int [] {
+        public final static int [] BG_EDIT_RESOURCES = new int [] {
             R.drawable.edit_yellow,
             R.drawable.edit_blue,
             R.drawable.edit_white,
@@ -178,4 +187,25 @@ public class ResourceParser {
             return TEXTAPPEARANCE_RESOURCES.length;
         }
     }
+
+    public static class TextColorResources {
+        private final static int [] TEXT_COLOR_RESOURCES = new int [] {
+            android.R.color.black,
+            android.R.color.holo_red_dark,
+            android.R.color.holo_blue_dark,
+            android.R.color.holo_green_dark,
+            android.R.color.white
+        };
+
+        public static int getTextColorResource(int id) {
+            if (id >= TEXT_COLOR_RESOURCES.length) {
+                return DEFAULT_FONT_COLOR;
+            }
+            return TEXT_COLOR_RESOURCES[id];
+        }
+
+        public static int getResourcesSize() {
+            return TEXT_COLOR_RESOURCES.length;
+        }
+    }
 }
diff --git a/app/src/main/java/net/micode/notes/ui/NoteEditActivity.java b/app/src/main/java/net/micode/notes/ui/NoteEditActivity.java
index 96a9ff8..30b80d3 100644
--- a/app/src/main/java/net/micode/notes/ui/NoteEditActivity.java
+++ b/app/src/main/java/net/micode/notes/ui/NoteEditActivity.java
@@ -30,9 +30,11 @@ import android.content.SharedPreferences;
 import android.graphics.Paint;
 import android.os.Bundle;
 import android.preference.PreferenceManager;
+import android.text.Editable;
 import android.text.Spannable;
 import android.text.SpannableString;
 import android.text.TextUtils;
+import android.text.TextWatcher;
 import android.text.format.DateUtils;
 import android.text.style.BackgroundColorSpan;
 import android.util.Log;
@@ -43,6 +45,7 @@ import android.view.MotionEvent;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.WindowManager;
+import android.widget.Button;
 import android.widget.CheckBox;
 import android.widget.CompoundButton;
 import android.widget.CompoundButton.OnCheckedChangeListener;
@@ -82,6 +85,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         public TextView tvAlertDate;
 
         public ImageView ibSetBgColor;
+        
+        public Button ibSetFontColor;
     }
 
     private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
@@ -118,6 +123,25 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
     }
 
+    // Font color maps
+    private static final Map<Integer, Integer> sFontColorBtnsMap = new HashMap<Integer, Integer>();
+    static {
+        sFontColorBtnsMap.put(R.id.iv_font_black, ResourceParser.FONT_COLOR_BLACK);
+        sFontColorBtnsMap.put(R.id.iv_font_red, ResourceParser.FONT_COLOR_RED);
+        sFontColorBtnsMap.put(R.id.iv_font_blue, ResourceParser.FONT_COLOR_BLUE);
+        sFontColorBtnsMap.put(R.id.iv_font_green, ResourceParser.FONT_COLOR_GREEN);
+        sFontColorBtnsMap.put(R.id.iv_font_white, ResourceParser.FONT_COLOR_WHITE);
+    }
+
+    private static final Map<Integer, Integer> sFontColorSelectorSelectionMap = new HashMap<Integer, Integer>();
+    static {
+        sFontColorSelectorSelectionMap.put(ResourceParser.FONT_COLOR_BLACK, R.id.iv_font_black_select);
+        sFontColorSelectorSelectionMap.put(ResourceParser.FONT_COLOR_RED, R.id.iv_font_red_select);
+        sFontColorSelectorSelectionMap.put(ResourceParser.FONT_COLOR_BLUE, R.id.iv_font_blue_select);
+        sFontColorSelectorSelectionMap.put(ResourceParser.FONT_COLOR_GREEN, R.id.iv_font_green_select);
+        sFontColorSelectorSelectionMap.put(ResourceParser.FONT_COLOR_WHITE, R.id.iv_font_white_select);
+    }
+
     private static final String TAG = "NoteEditActivity";
 
     private HeadViewHolder mNoteHeaderHolder;
@@ -125,6 +149,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
     private View mHeadViewPanel;
 
     private View mNoteBgColorSelector;
+    
+    private View mFontColorSelector;
 
     private View mFontSizeSelector;
 
@@ -136,8 +162,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
 
     private SharedPreferences mSharedPrefs;
     private int mFontSizeId;
+    private int mFontColorId;
 
     private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
+    private static final String PREFERENCE_FONT_COLOR = "pref_font_color";
 
     private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
 
@@ -148,6 +176,25 @@ public class NoteEditActivity extends Activity implements OnClickListener,
 
     private String mUserQuery;
     private Pattern mPattern;
+    
+    // 定义mTextWatcher变量
+    private TextWatcher mTextWatcher = new TextWatcher() {
+        @Override
+        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+            // 此方法为接口必须实现的方法，但我们不需要在此做任何操作
+        }
+
+        @Override
+        public void onTextChanged(CharSequence s, int start, int before, int count) {
+            // 此方法为接口必须实现的方法，但我们不需要在此做任何操作
+        }
+
+        @Override
+        public void afterTextChanged(Editable s) {
+            // 文本变化后的处理逻辑
+            // 此处可以留空，因为我们目前没有特殊的处理需求
+        }
+    };
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -370,31 +417,50 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
         mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
         mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
-        mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
+        mNoteHeaderHolder.ibSetFontColor = (Button) findViewById(R.id.btn_set_font_color);
         mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
         mNoteEditorPanel = findViewById(R.id.sv_note_edit);
         mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
-        for (int id : sBgSelectorBtnsMap.keySet()) {
+        mFontColorSelector = findViewById(R.id.font_color_selector);
+        mFontSizeSelector = findViewById(R.id.font_size_selector);
+        mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
+
+        mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
+        mNoteHeaderHolder.ibSetFontColor.setOnClickListener(this);
+
+        /**
+         * Initialize the Chinese input method editor watcher
+         */
+        mNoteEditor.addTextChangedListener(mTextWatcher);
+
+        for (Integer id : sBgSelectorBtnsMap.keySet()) {
             ImageView iv = (ImageView) findViewById(id);
             iv.setOnClickListener(this);
         }
 
-        mFontSizeSelector = findViewById(R.id.font_size_selector);
-        for (int id : sFontSizeBtnsMap.keySet()) {
+        for (Integer id : sFontSizeBtnsMap.keySet()) {
             View view = findViewById(id);
             view.setOnClickListener(this);
-        };
+        }
+        
+        for (Integer id : sFontColorBtnsMap.keySet()) {
+            View view = findViewById(id);
+            view.setOnClickListener(this);
+        }
+
         mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
         mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
+        mFontColorId = mSharedPrefs.getInt(PREFERENCE_FONT_COLOR, ResourceParser.DEFAULT_FONT_COLOR);
         /**
-         * HACKME: Fix bug of store the resource id in shared preference.
-         * The id may larger than the length of resources, in this case,
-         * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
+         * Prepare for setting font size
          */
-        if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
-            mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
-        }
-        mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
+        mNoteEditor.setTextAppearance(this, ResourceParser.TextAppearanceResources
+                .getTexAppearanceResource(mFontSizeId));
+        /**
+         * Set font color
+         */
+        mNoteEditor.setTextColor(getResources().getColor(
+                ResourceParser.TextColorResources.getTextColorResource(mFontColorId)));
     }
 
     @Override
@@ -425,30 +491,86 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         setResult(RESULT_OK, intent);
     }
 
+    @Override
     public void onClick(View v) {
         int id = v.getId();
         if (id == R.id.btn_set_bg_color) {
-            mNoteBgColorSelector.setVisibility(View.VISIBLE);
-            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
-                    -                    View.VISIBLE);
-        } else if (sBgSelectorBtnsMap.containsKey(id)) {
-            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
-                    View.GONE);
-            mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
-            mNoteBgColorSelector.setVisibility(View.GONE);
-        } else if (sFontSizeBtnsMap.containsKey(id)) {
-            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
-            mFontSizeId = sFontSizeBtnsMap.get(id);
-            mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
-            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
-            if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
-                getWorkingText();
-                switchToListMode(mWorkingNote.getContent());
+            // user clicks to set background
+            if (mNoteBgColorSelector.getVisibility() == View.GONE) {
+                mFontSizeSelector.setVisibility(View.GONE);
+                mFontColorSelector.setVisibility(View.GONE);
+                mNoteBgColorSelector.setVisibility(View.VISIBLE);
+                if (mWorkingNote.getBgColorId() >= 0
+                        && mWorkingNote.getBgColorId() < ResourceParser.NoteBgResources.BG_EDIT_RESOURCES.length) {
+                    findViewById(
+                            sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
+                            View.VISIBLE);
+                }
             } else {
-                mNoteEditor.setTextAppearance(this,
-                        TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
+                mNoteBgColorSelector.setVisibility(View.GONE);
+            }
+            return;
+        } else if (id == R.id.btn_set_font_color) {
+            // user clicks to set font color
+            if (mFontColorSelector.getVisibility() == View.GONE) {
+                mNoteBgColorSelector.setVisibility(View.GONE);
+                mFontSizeSelector.setVisibility(View.GONE);
+                mFontColorSelector.setVisibility(View.VISIBLE);
+                if (mFontColorId >= 0 && mFontColorId < ResourceParser.TextColorResources.getResourcesSize()) {
+                    findViewById(sFontColorSelectorSelectionMap.get(mFontColorId)).setVisibility(View.VISIBLE);
+                }
+            } else {
+                mFontColorSelector.setVisibility(View.GONE);
+            }
+            return;
+        }
+
+        /**
+         * User choose a color to set, should change the UI and save it
+         */
+        for (Map.Entry<Integer, Integer> entry : sBgSelectorBtnsMap.entrySet()) {
+            if (entry.getKey() == id) {
+                int bgColorId = entry.getValue();
+                findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
+                        View.GONE);
+                mWorkingNote.setBgColorId(bgColorId);
+                mNoteBgColorSelector.setVisibility(View.GONE);
+                break;
+            }
+        }
+
+        /**
+         * User choose a font size to set, should change the UI and save it
+         */
+        for (Map.Entry<Integer, Integer> entry : sFontSizeBtnsMap.entrySet()) {
+            if (entry.getKey() == id) {
+                int fontSizeId = entry.getValue();
+                findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
+                mFontSizeId = fontSizeId;
+                findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
+                mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).apply();
+                mNoteEditor.setTextAppearance(this, ResourceParser.TextAppearanceResources
+                        .getTexAppearanceResource(mFontSizeId));
+                mFontSizeSelector.setVisibility(View.GONE);
+                break;
+            }
+        }
+
+        /**
+         * User choose a font color to set, should change the UI and save it
+         */
+        for (Map.Entry<Integer, Integer> entry : sFontColorBtnsMap.entrySet()) {
+            if (entry.getKey() == id) {
+                int fontColorId = entry.getValue();
+                findViewById(sFontColorSelectorSelectionMap.get(mFontColorId)).setVisibility(View.GONE);
+                mFontColorId = fontColorId;
+                findViewById(sFontColorSelectorSelectionMap.get(mFontColorId)).setVisibility(View.VISIBLE);
+                mSharedPrefs.edit().putInt(PREFERENCE_FONT_COLOR, mFontColorId).apply();
+                mNoteEditor.setTextColor(getResources().getColor(
+                        ResourceParser.TextColorResources.getTextColorResource(mFontColorId)));
+                mFontColorSelector.setVisibility(View.GONE);
+                break;
             }
-            mFontSizeSelector.setVisibility(View.GONE);
         }
     }
 
@@ -469,6 +591,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         } else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
             mFontSizeSelector.setVisibility(View.GONE);
             return true;
+        } else if (mFontColorSelector.getVisibility() == View.VISIBLE) {
+            mFontColorSelector.setVisibility(View.GONE);
+            return true;
         }
         return false;
     }
diff --git a/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider.java b/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider.java
index ec6f819..c08aa13 100644
--- a/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider.java
+++ b/app/src/main/java/net/micode/notes/widget/NoteWidgetProvider.java
@@ -69,60 +69,85 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
         update(context, appWidgetManager, appWidgetIds, false);
     }
 
-    private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
-            boolean privacyMode) {
-        for (int i = 0; i < appWidgetIds.length; i++) {
-            if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
-                int bgId = ResourceParser.getDefaultBgId(context);
-                String snippet = "";
-                Intent intent = new Intent(context, NoteEditActivity.class);
-                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
-                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
-                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
-
-                Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
-                if (c != null && c.moveToFirst()) {
-                    if (c.getCount() > 1) {
-                        Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
-                        c.close();
-                        return;
-                    }
-                    snippet = c.getString(COLUMN_SNIPPET);
-                    bgId = c.getInt(COLUMN_BG_COLOR_ID);
-                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
-                    intent.setAction(Intent.ACTION_VIEW);
-                } else {
-                    snippet = context.getResources().getString(R.string.widget_havenot_content);
-                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
-                }
-
-                if (c != null) {
+    /**
+ * 更新笔记小部件的内容和外观
+ *
+ * 这是NoteWidgetProvider类的核心方法，负责：
+ * 1. 根据widgetId查询关联的笔记内容
+ * 2. 设置小部件背景和文本内容
+ * 3. 配置点击行为(编辑笔记/隐私模式)
+ *
+ * @param context 上下文对象，用于获取资源和服务
+ * @param appWidgetManager AppWidgetManager实例，用于管理小部件
+ * @param appWidgetIds 要更新的小部件ID数组
+ * @param privacyMode 隐私模式标志，true时显示占位文本
+ */
+private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
+        boolean privacyMode) {
+    // 遍历所有需要更新的小部件ID
+    for (int i = 0; i < appWidgetIds.length; i++) {
+        if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_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()) {
+                // 检查是否存在重复widgetId的笔记
+                if (c.getCount() > 1) {
+                    Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
                     c.close();
+                    return;
                 }
+                // 获取笔记内容和背景色
+                snippet = c.getString(COLUMN_SNIPPET);
+                bgId = c.getInt(COLUMN_BG_COLOR_ID);
+                intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
+                intent.setAction(Intent.ACTION_VIEW);  // 查看模式
+            } else {
+                // 没有关联笔记时使用默认内容
+                snippet = context.getResources().getString(R.string.widget_havenot_content);
+                intent.setAction(Intent.ACTION_INSERT_OR_EDIT);  // 新建/编辑模式
+            }
 
-                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 = 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);
-                }
+            if (c != null) {
+                c.close();
+            }
 
-                rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
-                appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
+            // 配置RemoteViews
+            RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
+            rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
+            intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
+
+            // 设置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);
         }
     }
+}
+
 
     protected abstract int getBgResourceId(int bgId);
 
diff --git a/app/src/main/res/layout/note_edit.xml b/app/src/main/res/layout/note_edit.xml
index 10b2aa7..d4c91b8 100644
--- a/app/src/main/res/layout/note_edit.xml
+++ b/app/src/main/res/layout/note_edit.xml
@@ -123,6 +123,18 @@
         android:background="@drawable/bg_color_btn_mask"
         android:layout_gravity="top|right" />
 
+    <Button
+        android:id="@+id/btn_set_font_color"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/menu_font_color"
+        android:drawableLeft="@android:drawable/ic_menu_edit"
+        android:drawablePadding="5dp"
+        android:padding="10dp"
+        android:layout_marginBottom="20dp"
+        android:layout_marginLeft="10dp"
+        android:layout_gravity="bottom|left" />
+
     <LinearLayout
         android:id="@+id/note_bg_color_selector"
         android:layout_width="wrap_content"
@@ -237,6 +249,125 @@
         </FrameLayout>
     </LinearLayout>
 
+    <LinearLayout
+        android:id="@+id/font_color_selector"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:background="@drawable/note_edit_color_selector_panel"
+        android:layout_marginBottom="70dip"
+        android:layout_marginLeft="8dip"
+        android:layout_gravity="bottom|left"
+        android:visibility="gone">
+
+        <FrameLayout
+            android:layout_width="0dip"
+            android:layout_height="match_parent"
+            android:layout_weight="1">
+
+            <ImageView
+                android:id="@+id/iv_font_black"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:background="@android:color/black" />
+
+            <ImageView
+                android:id="@+id/iv_font_black_select"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_gravity="bottom|right"
+                android:layout_marginRight="5dip"
+                android:focusable="false"
+                android:visibility="gone"
+                android:src="@drawable/selected" />
+        </FrameLayout>
+
+        <FrameLayout
+            android:layout_width="0dip"
+            android:layout_height="match_parent"
+            android:layout_weight="1">
+
+            <ImageView
+                android:id="@+id/iv_font_red"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:background="@android:color/holo_red_dark" />
+
+            <ImageView
+                android:id="@+id/iv_font_red_select"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_gravity="bottom|right"
+                android:focusable="false"
+                android:visibility="gone"
+                android:layout_marginRight="3dip"
+                android:src="@drawable/selected" />
+        </FrameLayout>
+
+        <FrameLayout
+            android:layout_width="0dip"
+            android:layout_height="match_parent"
+            android:layout_weight="1">
+
+            <ImageView
+                android:id="@+id/iv_font_blue"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:background="@android:color/holo_blue_dark" />
+
+            <ImageView
+                android:id="@+id/iv_font_blue_select"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_gravity="bottom|right"
+                android:focusable="false"
+                android:visibility="gone"
+                android:layout_marginRight="2dip"
+                android:src="@drawable/selected" />
+        </FrameLayout>
+
+        <FrameLayout
+            android:layout_width="0dip"
+            android:layout_height="match_parent"
+            android:layout_weight="1">
+
+            <ImageView
+                android:id="@+id/iv_font_green"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:background="@android:color/holo_green_dark" />
+
+            <ImageView
+                android:id="@+id/iv_font_green_select"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_gravity="bottom|right"
+                android:focusable="false"
+                android:visibility="gone"
+                android:src="@drawable/selected" />
+        </FrameLayout>
+
+        <FrameLayout
+            android:layout_width="0dip"
+            android:layout_height="match_parent"
+            android:layout_weight="1">
+
+            <ImageView
+                android:id="@+id/iv_font_white"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:background="@android:color/white" />
+
+            <ImageView
+                android:id="@+id/iv_font_white_select"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_gravity="bottom|right"
+                android:focusable="false"
+                android:visibility="gone"
+                android:src="@drawable/selected" />
+        </FrameLayout>
+    </LinearLayout>
+
     <LinearLayout
         android:id="@+id/font_size_selector"
         android:layout_width="fill_parent"
diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml
index 09f75ed..8b878a5 100644
--- a/app/src/main/res/values-zh-rCN/strings.xml
+++ b/app/src/main/res/values-zh-rCN/strings.xml
@@ -49,10 +49,16 @@
     <string name="menu_select_all">全选</string>
     <string name="menu_deselect_all">取消全选</string>
     <string name="menu_font_size">文字大小</string>
+    <string name="menu_font_color">文字颜色</string>
     <string name="menu_font_small">小</string>
     <string name="menu_font_normal">正常</string>
     <string name="menu_font_large">大</string>
     <string name="menu_font_super">超大</string>
+    <string name="menu_font_color_black">黑色</string>
+    <string name="menu_font_color_red">红色</string>
+    <string name="menu_font_color_blue">蓝色</string>
+    <string name="menu_font_color_green">绿色</string>
+    <string name="menu_font_color_white">白色</string>
     <string name="menu_list_mode">进入清单模式</string>
     <string name="menu_normal_mode">退出清单模式</string>
     <string name="menu_folder_view">查看文件夹</string>
@@ -110,6 +116,7 @@
     <string name="preferences_toast_cannot_change_account">正在同步中，不能修改同步帐号</string>
     <string name="preferences_toast_success_set_accout">同步帐号已设置为%1$s</string>
     <string name="preferences_bg_random_appear_title">新建便签背景颜色随机</string>
+    <string name="pref_title_font_color">文字颜色</string>
     <string name="button_delete">删除</string>
     <string name="call_record_folder_name">通话便签</string>
     <string name="hint_foler_name">请输入名称</string>
@@ -120,7 +127,7 @@
     <string name="datetime_dialog_ok">设置</string>
     <string name="datetime_dialog_cancel">取消</string>
     <plurals name="search_results_title">
-        <item quantity="other"><xliff:g id="NUMBER">%1$s</xliff:g> 条符合“<xliff:g id="SEARCH">%2$s</xliff:g>”的搜索结果</item>
+        <item quantity="other"><xliff:g id="NUMBER">%1$s</xliff:g> 条符合"<xliff:g id="SEARCH">%2$s</xliff:g>"的搜索结果</item>
     </plurals>
 
 </resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 55df868..c881706 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -53,10 +53,16 @@
     <string name="menu_select_all">Select all</string>
     <string name="menu_deselect_all">Deselect all</string>
     <string name="menu_font_size">Font size</string>
+    <string name="menu_font_color">Font color</string>
     <string name="menu_font_small">Small</string>
     <string name="menu_font_normal">Medium</string>
     <string name="menu_font_large">Large</string>
     <string name="menu_font_super">Super</string>
+    <string name="menu_font_color_black">Black</string>
+    <string name="menu_font_color_red">Red</string>
+    <string name="menu_font_color_blue">Blue</string>
+    <string name="menu_font_color_green">Green</string>
+    <string name="menu_font_color_white">White</string>
     <string name="menu_list_mode">Enter check list</string>
     <string name="menu_normal_mode">Leave check list</string>
     <string name="menu_folder_view">View folder</string>
@@ -64,7 +70,7 @@
     <string name="menu_folder_change_name">Change folder name</string>
     <string name="folder_exist">The folder %1$s exist, please rename</string>
     <string name="menu_share">Share</string>
-    <string name="menu_send_to_desktop">Send to home</string>
+    <string name="menu_send_to_desktop">Send to desktop</string>
     <string name="menu_alert">Remind me</string>
     <string name="menu_remove_remind">Delete reminder</string>
     <string name="menu_title_select_folder">Select folder</string>
@@ -132,4 +138,9 @@
         <item quantity="other"><xliff:g id="number" example="15">%1$s</xliff:g> results for \"<xliff:g id="search" example="???">%2$s</xliff:g>\"</item>
     </plurals>
 
+    <!-- settings -->
+    <string name="pref_title_font_size">Font size</string>
+    <string name="pref_title_font_color">Font color</string>
+    <string name="pref_title_note_style">Note style</string>
+
 </resources>