67 changed files with 862 additions and 4193 deletions
--- a/doc/小米便签泛读报告.docx
+++ b/doc/小米便签泛读报告.docx
--- a/doc/小米便签质量分析报告.docx
+++ b/doc/小米便签质量分析报告.docx
--- a/doc/阅读记录.docx
+++ b/doc/阅读记录.docx
--- a/src/Notes-master/res/.idea/.gitignore
+++ b/src/Notes-master/res/.idea/.gitignore
@ -0,0 +1,3 @@
 # Default ignored files
 /shelf/
 /workspace.xml
--- a/src/Notes-master/res/.idea/AndroidProjectSystem.xml
+++ b/src/Notes-master/res/.idea/AndroidProjectSystem.xml
@ -0,0 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="AndroidProjectSystem">
    <option name="providerId" value="com.android.tools.idea.GradleProjectSystem" />
  </component>
 </project>
--- a/src/Notes-master/res/.idea/gradle.xml
+++ b/src/Notes-master/res/.idea/gradle.xml
@ -0,0 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="GradleSettings">
    <option name="linkedExternalProjectsSettings">
      <GradleProjectSettings>
        <option name="testRunner" value="CHOOSE_PER_TEST" />
        <option name="externalProjectPath" value="$PROJECT_DIR$" />
        <option name="gradleJvm" value="#JAVA_HOME" />
      </GradleProjectSettings>
    </option>
  </component>
 </project>
--- a/src/Notes-master/res/.idea/misc.xml
+++ b/src/Notes-master/res/.idea/misc.xml
@ -0,0 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ExternalStorageConfigurationManager" enabled="true" />
  <component name="ProjectRootManager">
    <output url="file://$PROJECT_DIR$/out" />
  </component>
 </project>
--- a/src/Notes-master/res/.idea/runConfigurations.xml
+++ b/src/Notes-master/res/.idea/runConfigurations.xml
@ -0,0 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="RunConfigurationProducerService">
    <option name="ignoredProducers">
      <set>
        <option value="com.intellij.execution.junit.AbstractAllInDirectoryConfigurationProducer" />
        <option value="com.intellij.execution.junit.AllInPackageConfigurationProducer" />
        <option value="com.intellij.execution.junit.PatternConfigurationProducer" />
        <option value="com.intellij.execution.junit.TestInClassConfigurationProducer" />
        <option value="com.intellij.execution.junit.UniqueIdConfigurationProducer" />
        <option value="com.intellij.execution.junit.testDiscovery.JUnitTestDiscoveryConfigurationProducer" />
        <option value="org.jetbrains.kotlin.idea.junit.KotlinJUnitRunConfigurationProducer" />
        <option value="org.jetbrains.kotlin.idea.junit.KotlinPatternConfigurationProducer" />
      </set>
    </option>
  </component>
 </project>
--- a/src/Notes-master/res/drawable/ic_launcher_background.xml
+++ b/src/Notes-master/res/drawable/ic_launcher_background.xml
@ -1,170 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="108dp"
    android:height="108dp"
    android:viewportWidth="108"
    android:viewportHeight="108">
    <path
        android:fillColor="#3DDC84"
        android:pathData="M0,0h108v108h-108z" />
    <path
        android:fillColor="#00000000"
        android:pathData="M9,0L9,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,0L19,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M29,0L29,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M39,0L39,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M49,0L49,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M59,0L59,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M69,0L69,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M79,0L79,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M89,0L89,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M99,0L99,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,9L108,9"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,19L108,19"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,29L108,29"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,39L108,39"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,49L108,49"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,59L108,59"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,69L108,69"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,79L108,79"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,89L108,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,99L108,99"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,29L89,29"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,39L89,39"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,49L89,49"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,59L89,59"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,69L89,69"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,79L89,79"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M29,19L29,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M39,19L39,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M49,19L49,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M59,19L59,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M69,19L69,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M79,19L79,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
 </vector>
--- a/src/Notes-master/res/drawable/ic_launcher_foreground.xml
+++ b/src/Notes-master/res/drawable/ic_launcher_foreground.xml
@ -1,30 +0,0 @@
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:aapt="http://schemas.android.com/aapt"
    android:width="108dp"
    android:height="108dp"
    android:viewportWidth="108"
    android:viewportHeight="108">
    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
        <aapt:attr name="android:fillColor">
            <gradient
                android:endX="85.84757"
                android:endY="92.4963"
                android:startX="42.9492"
                android:startY="49.59793"
                android:type="linear">
                <item
                    android:color="#44000000"
                    android:offset="0.0" />
                <item
                    android:color="#00000000"
                    android:offset="1.0" />
            </gradient>
        </aapt:attr>
    </path>
    <path
        android:fillColor="#FFFFFF"
        android:fillType="nonZero"
        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
        android:strokeWidth="1"
        android:strokeColor="#00000000" />
 </vector>
--- a/src/Notes-master/res/layout/activity_main.xml
+++ b/src/Notes-master/res/layout/activity_main.xml
@ -1,19 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
 </androidx.constraintlayout.widget.ConstraintLayout>
--- a/src/Notes-master/res/mipmap-anydpi/ic_launcher.xml
+++ b/src/Notes-master/res/mipmap-anydpi/ic_launcher.xml
@ -1,6 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@drawable/ic_launcher_background" />
    <foreground android:drawable="@drawable/ic_launcher_foreground" />
    <monochrome android:drawable="@drawable/ic_launcher_foreground" />
 </adaptive-icon>
--- a/src/Notes-master/res/mipmap-anydpi/ic_launcher_round.xml
+++ b/src/Notes-master/res/mipmap-anydpi/ic_launcher_round.xml
@ -1,6 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@drawable/ic_launcher_background" />
    <foreground android:drawable="@drawable/ic_launcher_foreground" />
    <monochrome android:drawable="@drawable/ic_launcher_foreground" />
 </adaptive-icon>
--- a/src/Notes-master/res/mipmap-hdpi/ic_launcher.webp
+++ b/src/Notes-master/res/mipmap-hdpi/ic_launcher.webp
--- a/src/Notes-master/res/mipmap-hdpi/ic_launcher_round.webp
+++ b/src/Notes-master/res/mipmap-hdpi/ic_launcher_round.webp
--- a/src/Notes-master/res/mipmap-mdpi/ic_launcher.webp
+++ b/src/Notes-master/res/mipmap-mdpi/ic_launcher.webp
--- a/src/Notes-master/res/mipmap-mdpi/ic_launcher_round.webp
+++ b/src/Notes-master/res/mipmap-mdpi/ic_launcher_round.webp
--- a/src/Notes-master/res/mipmap-xhdpi/ic_launcher.webp
+++ b/src/Notes-master/res/mipmap-xhdpi/ic_launcher.webp
--- a/src/Notes-master/res/mipmap-xhdpi/ic_launcher_round.webp
+++ b/src/Notes-master/res/mipmap-xhdpi/ic_launcher_round.webp
--- a/src/Notes-master/res/mipmap-xxhdpi/ic_launcher.webp
+++ b/src/Notes-master/res/mipmap-xxhdpi/ic_launcher.webp
--- a/src/Notes-master/res/mipmap-xxhdpi/ic_launcher_round.webp
+++ b/src/Notes-master/res/mipmap-xxhdpi/ic_launcher_round.webp
--- a/src/Notes-master/res/mipmap-xxxhdpi/ic_launcher.webp
+++ b/src/Notes-master/res/mipmap-xxxhdpi/ic_launcher.webp
--- a/src/Notes-master/res/mipmap-xxxhdpi/ic_launcher_round.webp
+++ b/src/Notes-master/res/mipmap-xxxhdpi/ic_launcher_round.webp
--- a/src/Notes-master/res/values-night/themes.xml
+++ b/src/Notes-master/res/values-night/themes.xml
@ -1,7 +0,0 @@
 <resources xmlns:tools="http://schemas.android.com/tools">
    <!-- Base application theme. -->
    <style name="Base.Theme.Notesmaster" parent="Theme.Material3.DayNight.NoActionBar">
        <!-- Customize your dark theme here. -->
        <!-- <item name="colorPrimary">@color/my_dark_primary</item> -->
    </style>
 </resources>
--- a/src/Notes-master/res/values/styles.xml
+++ b/src/Notes-master/res/values/styles.xml
@ -63,6 +63,7 @@
    </style>
    <style name="NoteActionBarStyle" parent="@android:style/Widget.Holo.Light.ActionBar.Solid">
-        <item name="android:visibility">visible</item>
+        <item name="android:displayOptions" />
        <item name="android:visibility">gone</item>
    </style>
 </resources>
--- a/src/Notes-master/res/values/themes.xml
+++ b/src/Notes-master/res/values/themes.xml
@ -1,9 +0,0 @@
 <resources xmlns:tools="http://schemas.android.com/tools">
    <!-- Base application theme. -->
    <style name="Base.Theme.Notesmaster" parent="Theme.Material3.DayNight.NoActionBar">
        <!-- Customize your light theme here. -->
        <!-- <item name="colorPrimary">@color/my_light_primary</item> -->
    </style>
    <style name="Theme.Notesmaster" parent="Base.Theme.Notesmaster" />
 </resources>
--- a/src/Notes-master/res/xml/backup_rules.xml
+++ b/src/Notes-master/res/xml/backup_rules.xml
@ -1,13 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?><!--
   Sample backup rules file; uncomment and customize as necessary.
   See https://developer.android.com/guide/topics/data/autobackup
   for details.
   Note: This file is ignored for devices older than API 31
   See https://developer.android.com/about/versions/12/backup-restore
 -->
 <full-backup-content>
    <!--
   <include domain="sharedpref" path="."/>
   <exclude domain="sharedpref" path="device.xml"/>
 -->
 </full-backup-content>
--- a/src/Notes-master/res/xml/data_extraction_rules.xml
+++ b/src/Notes-master/res/xml/data_extraction_rules.xml
@ -1,19 +0,0 @@
 <?xml version="1.0" encoding="utf-8"?><!--
   Sample data extraction rules file; uncomment and customize as necessary.
   See https://developer.android.com/about/versions/12/backup-restore#xml-changes
   for details.
 -->
 <data-extraction-rules>
    <cloud-backup>
        <!-- TODO: Use <include> and <exclude> to control what is backed up.
        <include .../>
        <exclude .../>
        -->
    </cloud-backup>
    <!--
    <device-transfer>
        <include .../>
        <exclude .../>
    </device-transfer>
    -->
 </data-extraction-rules>
--- a/src/Notes-master/src/net/micode/notes/data/Contact.java
+++ b/src/Notes-master/src/net/micode/notes/data/Contact.java
@ -25,92 +25,47 @@ import android.util.Log;
 import java.util.HashMap;
 /**
 * 联系人查询工具类
 * 核心功能：在小米便签中用于智能识别电话号码并显示联系人名称
 * 实现方法：通过电话号码查询系统联系人的姓名，并通过哈希表缓存查询结果，避免重复查询，提升性能
 */
 public class Contact {
    // 功能：缓存查询结果，，暂时存储电话号码与联系人的映射关系，避免重复查询,节省开销
    private static HashMap<String, String> sContactCache;
    // 日志标签
    private static final String TAG = "Contact";
    // 查询联系人的选择条件
    private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
    + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
    + " AND " + Data.RAW_CONTACT_ID + " IN "
            + "(SELECT raw_contact_id "
            + " FROM phone_lookup"
            + " WHERE min_match = '+')";
    /**
     * SQL语句逻辑解读
     * AND 连接一个条件与下一个条件
     * 第一个条件：PHONE_NUMBERS_EQUAL(Phone.NUMBER,?)
     * PHONE_NUMBERS_EQUAL 函数：Android系统提供的特殊函数，用于查找和Phone.NUMBER相同的电话号码
     * 第二个条件：Data.MIMETYPE = 'Phone.CONTENT_ITEM_TYPE'
     * 确保数据类型必须是电话号码类型
     * 第三个条件：Data.RAW_CONTACT_ID IN A
     * 联系人的ID必须存在于这个表格A中
     * 表格A：(SELECT raw_contact_id FROM phone_lookup WHERE min_match = '+')
     * phone_lookup：Android系统中的一个与联系人数据有关的特殊表
     * min_match：最小匹配位数
     * 预先计算一个电话号码的最小匹配形式的表格
     */
    /**
     * 根据电话号码获取联系人姓名。
     *
     * @param context 上下文对象，用于访问 ContentResolver
     * @param phoneNumber 电话号码（原始字符串，不做预处理）
     * @return 联系人姓名；未找到或异常时返回 null
     */
    public static String getContact(Context context, String phoneNumber) {
        // 如果缓存哈希表为空，则创建新的哈希表
        if(sContactCache == null) {
            sContactCache = new HashMap<String, String>();
        }
-        // 检查缓存中是否已有该电话号码对应的联系人
+
        // 检查缓存中是否已存在该电话号码的查询结果
        if(sContactCache.containsKey(phoneNumber)) {
            return sContactCache.get(phoneNumber);
        }
-        // 构建查询条件，替换min_match参数
+
        // PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)用于计算电话号码的最小匹配位数
        // 将占位符"+"替换为最小匹配数,以构建完整的查询语句
        String selection = CALLER_ID_SELECTION.replace("+",
                PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
        /**
         * 查询联系人数据库
         * context.getContentResolver().query：查询当前应用程序的数据
         */
        Cursor cursor = context.getContentResolver().query(
-                Data.CONTENT_URI,       // 查询URI
+                Data.CONTENT_URI,
-                new String [] { Phone.DISPLAY_NAME },   // 联系人的名称作为返回值
+                new String [] { Phone.DISPLAY_NAME },
-                selection,              // 查询条件
+                selection,
-                new String[] { phoneNumber },   // 电话号码作为查询参数
+                new String[] { phoneNumber },
-                null);                  // 无排序方式
+                null);
-        // 如果找到联系人，返回名称并缓存
+
        // 查询系统联系人数据库
        if (cursor != null && cursor.moveToFirst()) {
            try {
                // 获取第一行第一列的联系人姓名
                String name = cursor.getString(0);
                // 将联系人和电话号码存入缓存中，以便下次查找
                sContactCache.put(phoneNumber, name);
                return name;
            } catch (IndexOutOfBoundsException e) {
                // 发生数组越界异常，将异常记录到日志Log中
                Log.e(TAG, " Cursor get string error " + e.toString());
                return null;
            } finally {
                // 关闭Cursor，防止内存泄露
                cursor.close();
            }
        } else {
            // 没有找到匹配的联系人，将信息写入日志中
            Log.d(TAG, "No contact matched with number:" + phoneNumber);
            return null;
        }
--- a/src/Notes-master/src/net/micode/notes/data/Notes.java
+++ b/src/Notes-master/src/net/micode/notes/data/Notes.java
@ -17,43 +17,24 @@
 package net.micode.notes.data;
 import android.net.Uri;
 /**
 * 笔记应用的数据结构定义
 * 包含所有笔记相关的常量、接口和内部类定义
 * 纯定义类，不包含函数实现
 */
 public class Notes {
    // ContentProvider的授权标识 
    public static final String AUTHORITY = "micode_notes";
    // 日志标签
    public static final String TAG = "Notes";
    // 0类型：普通笔记
    public static final int TYPE_NOTE     = 0;
    // 1类型：文件夹 
    public static final int TYPE_FOLDER   = 1;
    // 2类型：系统文件夹 
    public static final int TYPE_SYSTEM   = 2;
    // 系统文件夹的 ID 定义。
    // #ID_ROOT_FOLDER 默认根文件夹
    // #ID_TEMPARAY_FOLDER 临时文件夹，移动笔记时的中转
    // #ID_CALL_RECORD_FOLDER 通话记录专用文件夹
    // #ID_TRASH_FOLER 回收站
    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 Extra 键常量，用于在 Android 组件间通过 Intent 传递数据，包括：
+     * Following IDs are system folders' identifiers
-     * 1. 提醒日期 
+     * {@link Notes#ID_ROOT_FOLDER } is default folder
-     * 2. 背景颜色ID
+     * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
-     * 3. 小部件ID
+     * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
     * 4. 小部件类型
     * 5. 文件夹ID
     * 6. 通话日期
     */
    public static final int ID_ROOT_FOLDER = 0;
    public static final int ID_TEMPARAY_FOLDER = -1;
    public static final int ID_CALL_RECORD_FOLDER = -2;
    public static final int ID_TRASH_FOLER = -3;
    public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
    public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
    public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
@ -61,176 +42,238 @@ 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";
    // 无效的小部件类型 -1
    public static final int TYPE_WIDGET_INVALIDE      = -1;
    // 2x2小部件类型 0
    public static final int TYPE_WIDGET_2X            = 0;
    // 4x4小部件类型 1
    public static final int TYPE_WIDGET_4X            = 1;
    /**
     * 数据类型常量定义
     */
    public static class DataConstants {
        // 普通笔记的MIME类型
        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
        // 通话记录笔记的MIME类型
        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
    }
    //  URI 是 ContentProvider 的标准访问入口，用于统一访问应用的数据。
    // 查询所有笔记和文件夹的URI
    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
    // 查询数据表的URI
    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
    /**
-     * NoteColumns 接口 - 便签表(notes表)列定义
+     * Uri to query all notes and folders
     * 定义了便签和文件夹数据库表的所有列名和类型
     */
    public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
    /**
-     * 笔记表的列名定义接口
+     * Uri to query data
     */
    public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
    public interface NoteColumns {
-        
+        /**
-        // 行的唯一ID
+         * The unique ID for a row
         * <P> Type: INTEGER (long) </P>
         */
        public static final String ID = "_id";
-        // 笔记或文件夹的父ID
+        /**
         * The parent's id for note or folder
         * <P> Type: INTEGER (long) </P>
         */
        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";
-        // 笔记的小部件ID
+        /**
         * Note's widget id
         * <P> Type: INTEGER (long) </P>
         */
        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";
-        // 笔记的背景颜色ID
+        /**
         * Note's background color's id
         * <P> Type: INTEGER (long) </P>
         */
        public static final String BG_COLOR_ID = "bg_color_id";
-        // 是否有附件；对于文本笔记没有附件，多媒体笔记至少有一个附件
+        /**
         * For text note, it doesn't has attachment, for multi-media
         * note, it has at least one attachment
         * <P> Type: INTEGER </P>
         */
        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";
-        // 最后一次同步的ID
+        /**
         * The last sync id
         * <P> Type: INTEGER (long) </P>
         */
        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";
-        // 移动到临时文件夹之前的原始父ID
+        /**
         * Original parent id before moving into temporary folder
         * <P> Type : INTEGER </P>
         */
        public static final String ORIGIN_PARENT_ID = "origin_parent_id";
-        // Google Task的ID
+        /**
         * The gtask id
         * <P> Type : TEXT </P>
         */
        public static final String GTASK_ID = "gtask_id";
-        // 版本号
+        /**
         * The version code
         * <P> Type : INTEGER (long) </P>
         */
        public static final String VERSION = "version";
    }
     /**
     * DataColumns 接口 - 便签数据表(data表)列定义
     * 定义了便签详细内容的数据表列名和类型
     * 使用MIME_TYPE字段区分不同类型的便签数据（文本便签、通话记录等）
     */
    public interface DataColumns {
-        // 行的唯一ID
+        /**
         * The unique ID for a row
         * <P> Type: INTEGER (long) </P>
         */
        public static final String ID = "_id";
-        // 该行数据项的MIME类型
+        /**
         * The MIME type of the item represented by this row.
         * <P> Type: Text </P>
         */
        public static final String MIME_TYPE = "mime_type";
-        // 该数据所属笔记的引用ID
+        /**
         * The reference id to note that this data belongs to
         * <P> Type: INTEGER (long) </P>
         */
        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";
-        // 通用数据列1
+
        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * integer data type
         * <P> Type: INTEGER </P>
         */
        public static final String DATA1 = "data1";
-        // 通用数据列2
+        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * integer data type
         * <P> Type: INTEGER </P>
         */
        public static final String DATA2 = "data2";
-        // 通用数据列3
+        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * TEXT data type
         * <P> Type: TEXT </P>
         */
        public static final String DATA3 = "data3";
-        // 通用数据列4
+        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * TEXT data type
         * <P> Type: TEXT </P>
         */
        public static final String DATA4 = "data4";
-        // 通用数据列5
+        /**
         * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
         * TEXT data type
         * <P> Type: TEXT </P>
         */
        public static final String DATA5 = "data5";
    }
    /**
     * TextNote 类 - 文本便签数据定义
     * 定义了文本便签特有的数据列和URI
     */
    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>
         */
        public static final String MODE = DATA1;
        // 清单模式常量
        public static final int MODE_CHECK_LIST = 1;
        // 普通模式常量
        public static final int MODE_NORMAL = 0;
        // 文本笔记的目录MIME类型
        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
        // 文本笔记的单项MIME类型
        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
        // 文本笔记的URI
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
    }
    /**
     * CallNote 类 - 通话记录便签数据定义
     * 定义了通话记录便签特有的数据列和URI
     */
    public static final class CallNote implements DataColumns {
-        // 通话日期
+        /**
         * Call date for this record
         * <P> Type: INTEGER (long) </P>
         */
        public static final String CALL_DATE = DATA1;
-        // 电话号码
+        /**
         * Phone number for this record
         * <P> Type: TEXT </P>
         */
        public static final String PHONE_NUMBER = DATA3;
        // 联系人姓名
        public static final String CONTACT_NAME = DATA4;
        // 通话记录笔记的目录MIME类型
        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
        // 通话记录笔记的单项MIME类型
        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
        // 通话记录笔记的URI
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
    }
 }
--- a/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
+++ b/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
@ -26,31 +26,21 @@ import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.DataConstants;
 import net.micode.notes.data.Notes.NoteColumns;
-/**
+
 * 笔记数据库帮助
 * 负责数据库的创建、升级和维护
 */
 public class NotesDatabaseHelper extends SQLiteOpenHelper {
-    private static final String DB_NAME = "note.db";  // 数据库名称
+    private static final String DB_NAME = "note.db";
-    private static final int DB_VERSION = 4;          // 数据库版本
+
-;
+    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 final String TAG = "NotesDatabaseHelper";  // 日志标签
+    private static NotesDatabaseHelper mInstance;
    private static NotesDatabaseHelper mInstance;              // 单例实例
    /** 数据库帮助类的单例实例 */
    private static final String CREATE_NOTE_TABLE_SQL =
        "CREATE TABLE " + TABLE.NOTE + "(" +
@ -73,7 +63,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
            NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
        ")";
    // 创建笔记数据表的SQL语句
    private static final String CREATE_DATA_TABLE_SQL =
        "CREATE TABLE " + TABLE.DATA + "(" +
            DataColumns.ID + " INTEGER PRIMARY KEY," +
@ -89,18 +78,24 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
            DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
        ")";
    // 创建笔记数据表中note_id列的索引
    private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
        "CREATE INDEX IF NOT EXISTS note_id_index ON " +
        TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
    /**
-     * 当笔记移动到文件夹时增加文件夹的笔记计数
+     * Increase folder's note count when move note to the folder
     */
-    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER ="CREATE TRIGGER increase_folder_count_on_update "+" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +" BEGIN " +"  UPDATE " + TABLE.NOTE +"   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +"  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +" END";
+    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
        "CREATE TRIGGER increase_folder_count_on_update "+
        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
        " BEGIN " +
        "  UPDATE " + TABLE.NOTE +
        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
        " END";
    /**
-     * 当笔记从文件夹移走时减少文件夹的笔记计数
+     * Decrease folder's note count when move note from folder
     */
    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
        "CREATE TRIGGER decrease_folder_count_on_update " +
@ -113,7 +108,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        " END";
    /**
-     * 当向文件夹中插入新笔记时增加文件夹的笔记计数
+     * Increase folder's note count when insert new note to the folder
     */
    private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
        "CREATE TRIGGER increase_folder_count_on_insert " +
@ -125,7 +120,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        " END";
    /**
-     * 当从文件夹中删除笔记时减少文件夹的笔记计数
+     * Decrease folder's note count when delete note from the folder
     */
    private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
        "CREATE TRIGGER decrease_folder_count_on_delete " +
@ -137,7 +132,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
        " END";
-    /**插入 TEXT_NOTE 类型的数据行时，用数据内容刷新 note.snippet */
+    /**
     * Update note's content when insert data with type {@link DataConstants#NOTE}
     */
    private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
        "CREATE TRIGGER update_note_content_on_insert " +
        " AFTER INSERT ON " + TABLE.DATA +
@ -148,7 +145,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
        " END";
-    /**更新 TEXT_NOTE 数据行时，同步更新 note.snippet */
+    /**
     * Update note's content when data with {@link DataConstants#NOTE} type has changed
     */
    private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
        "CREATE TRIGGER update_note_content_on_update " +
        " AFTER UPDATE ON " + TABLE.DATA +
@ -159,7 +158,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
        " END";
-    /** 删除 TEXT_NOTE 数据行时，清空 note.snippet */
+    /**
     * Update note's content when data with {@link DataConstants#NOTE} type has deleted
     */
    private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
        "CREATE TRIGGER update_note_content_on_delete " +
        " AFTER delete ON " + TABLE.DATA +
@ -171,7 +172,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        " END";
    /**
-     * 删除已删除笔记的数据
+     * Delete datas belong to note which has been deleted
     */
    private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
        "CREATE TRIGGER delete_data_on_delete " +
@ -182,7 +183,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        " END";
    /**
-     * 删除已删除文件夹下的所有笔记
+     * Delete notes belong to folder which has been deleted
     */
    private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
        "CREATE TRIGGER folder_delete_notes_on_delete " +
@ -193,7 +194,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        " END";
    /**
-     * 当文件夹被移到回收站时，将其所有笔记也移到回收站
+     * Move notes belong to folder which has been moved to trash folder
     */
    private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
        "CREATE TRIGGER folder_move_notes_on_trash " +
@ -205,31 +206,18 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
        " END";
    /**
     * 构造方法
     * @param context 上下文对象
     */
    public NotesDatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }
    /**
     * 创建笔记表
     * @param db 数据库对象
     */
    public void createNoteTable(SQLiteDatabase db) {
-        db.execSQL(CREATE_NOTE_TABLE_SQL);  // 创建笔记表结构
+        db.execSQL(CREATE_NOTE_TABLE_SQL);
-        reCreateNoteTableTriggers(db);      // 重建笔记表触发器
+        reCreateNoteTableTriggers(db);
-        createSystemFolder(db);             // 创建系统文件夹
+        createSystemFolder(db);
        Log.d(TAG, "note table has been created");
    }
    /**
     * 重建笔记表的触发器
     * @param db 数据库对象
     */
    private void reCreateNoteTableTriggers(SQLiteDatabase db) {
        // 删除现有触发器
        db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
        db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
@ -238,7 +226,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
        db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
        // 创建新触发器
        db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
        db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
@ -248,71 +235,58 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
    }
    /**
     * 创建系统文件夹
     * @param db 数据库对象
     */
    private void createSystemFolder(SQLiteDatabase db) {
        ContentValues values = new ContentValues();
        /**
-         * 通话记录文件夹，用于存储通话记录笔记
+         * call record foler for call notes
         */
        values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
        db.insert(TABLE.NOTE, null, values);
-        // 创建根文件夹（默认文件夹）
+        /**
         * root folder which is default folder
         */
        values.clear();
        values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
        db.insert(TABLE.NOTE, null, values);
-        // 创建临时文件夹（用于移动笔记）
+        /**
         * temporary folder which is used for moving note
         */
        values.clear();
        values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
        db.insert(TABLE.NOTE, null, values);
-        // 创建回收站文件夹
+        /**
         * create trash folder
         */
        values.clear();
        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
        db.insert(TABLE.NOTE, null, values);
    }
    /**
     * 创建笔记数据表
     * @param db 数据库对象
     */
    public void createDataTable(SQLiteDatabase db) {
-        db.execSQL(CREATE_DATA_TABLE_SQL);           // 创建笔记数据表结构
+        db.execSQL(CREATE_DATA_TABLE_SQL);
-        reCreateDataTableTriggers(db);               // 重建笔记数据表触发器
+        reCreateDataTableTriggers(db);
-        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);    // 创建note_id列索引
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
        Log.d(TAG, "data table has been created");
    }
    /**
     * 重建笔记数据表的触发器
     * @param db 数据库对象
     */
    private void reCreateDataTableTriggers(SQLiteDatabase db) {
        // 删除现有触发器
        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
        db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
        // 创建新触发器
        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
        db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
    }
    /**
     * 获取NotesDatabaseHelper的单例实例
     * @param context 上下文对象
     * @return NotesDatabaseHelper的单例实例
     */
    static synchronized NotesDatabaseHelper getInstance(Context context) {
        if (mInstance == null) {
            mInstance = new NotesDatabaseHelper(context);
@ -320,97 +294,67 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
        return mInstance;
    }
    /** 创建数据库：依次创建 note 表与 data 表 */
    @Override
    public void onCreate(SQLiteDatabase db) {
-
+        createNoteTable(db);
-        createNoteTable(db);   // 创建笔记表
+        createDataTable(db);
        createDataTable(db);   // 创建笔记数据表
    }
    /**
     * 当数据库版本需要更新时调用
     * @param db 数据库对象
     * @param oldVersion 旧版本号
     * @param newVersion 新版本号
     */
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-      
+        boolean reCreateTriggers = false;
-        boolean reCreateTriggers = false;  // 是否需要重建触发器
+        boolean skipV2 = false;
        boolean skipV2 = false;            // 是否跳过版本2的升级
        // 从版本1升级
        if (oldVersion == 1) {
            upgradeToV2(db);
-
+            skipV2 = true; // this upgrade including the upgrade from v2 to v3
            oldVersion++;
        }
        // 从版本2升级（跳过已在版本1升级中处理的情况）
        if (oldVersion == 2 && !skipV2) {
            upgradeToV3(db);
            reCreateTriggers = true;
            oldVersion++;
        }
        // 从版本3升级
        if (oldVersion == 3) {
            upgradeToV4(db);
            oldVersion++;
        }
        // 如果需要，重建触发器
        if (reCreateTriggers) {
            reCreateNoteTableTriggers(db);
            reCreateDataTableTriggers(db);
        }
        // 检查升级是否成功
        if (oldVersion != newVersion) {
-            throw new IllegalStateException("Upgrade notes database to version " + newVersion);
+            throw new IllegalStateException("Upgrade notes database to version " + newVersion
-
+                    + "fails");
        }
    }
    /**
     * 将数据库升级到版本2
     * @param db 数据库对象
     */
    private void upgradeToV2(SQLiteDatabase db) {
        // 删除旧表
        db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
        db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
        // 创建新表
        createNoteTable(db);
        createDataTable(db);
    }
    /**
     * 将数据库升级到版本3
     * @param db 数据库对象
     */
    private void upgradeToV3(SQLiteDatabase db) {
-        // 删除不再使用的触发器
+        // drop unused triggers
        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
        db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
-        
+        // add a column for gtask id
        // 添加gtask_id列用于同步
        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
                + " TEXT NOT NULL DEFAULT ''");
-        
+        // add a trash system folder
        // 添加回收站系统文件夹
        ContentValues values = new ContentValues();
        values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
        values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
        db.insert(TABLE.NOTE, null, values);
    }
    /**
     * 将数据库升级到版本4
     * @param db 数据库对象
     */
    private void upgradeToV4(SQLiteDatabase db) {
        db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
                + " INTEGER NOT NULL DEFAULT 0");
--- a/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
+++ b/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
@ -35,58 +35,35 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 /**
 * 笔记内容提供者
 * 负责处理笔记和数据的CRUD操作，提供ContentProvider接口
 * 支持搜索和搜索建议功能
 */
 public class NotesProvider extends ContentProvider {
    private static final UriMatcher mMatcher;
    private static final UriMatcher mMatcher;  // URI匹配器，用于解析不同类型的URI请求
    // 数据库帮助类实例，负责获取读写数据库
    private NotesDatabaseHelper mHelper;
-    private static final String TAG = "NotesProvider";  // 日志标签
+    private static final String TAG = "NotesProvider";
    // URI匹配码：笔记列表
    private static final int URI_NOTE            = 1;
    // URI匹配码：单个笔记
    private static final int URI_NOTE_ITEM       = 2;
    // URI匹配码：数据列表
    private static final int URI_DATA            = 3;
    // URI匹配码：单个数据项
    private static final int URI_DATA_ITEM       = 4;
    // URI匹配码：搜索
    private static final int URI_SEARCH          = 5;
    // URI匹配码：搜索建议
    private static final int URI_SEARCH_SUGGEST  = 6;
    /**
     * 静态初始化块 - 配置URI匹配规则
     */
    static {
        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        // 笔记集合URI
        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
        // 单个笔记URI（带ID）
        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
        // 笔记数据集合URI
        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
        // 单个笔记数据URI（带ID）
        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
        // 搜索URI
        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
        // 搜索建议URI（两种形式）
        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
    }
    /**
-     * 笔记搜索投影字段。
+     * x'0A' represents the '\n' character in sqlite. For title and content in the search result,
-     * x'0A' 代表 SQLite 中的换行符；搜索时去掉换行与空格，便于列表展示更多内容。
+     * we will trim '\n' and white space in order to show more information.
     */
    private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
        + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
@ -96,35 +73,18 @@ public class NotesProvider extends ContentProvider {
        + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
        + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
    /**
     * 笔记片段搜索查询语句
     * 只搜索非回收站中的普通笔记，根据内容片段进行模糊匹配
     */
    private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
        + " FROM " + TABLE.NOTE
        + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
        + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
        + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
    /**
     * 内容提供者创建时调用
     * 初始化数据库帮助类实例
     */
    @Override
    public boolean onCreate() {
        mHelper = NotesDatabaseHelper.getInstance(getContext());
        return true;
    }
    /**
     * 查询方法 - 处理对笔记和数据的查询请求
     * @param uri 请求的URI
     * @param projection 查询的列
     * @param selection 查询条件
     * @param selectionArgs 查询条件参数
     * @param sortOrder 排序方式
     * @return 查询结果游标
     */
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
            String sortOrder) {
@ -132,27 +92,26 @@ public class NotesProvider extends ContentProvider {
        SQLiteDatabase db = mHelper.getReadableDatabase();
        String id = null;
        switch (mMatcher.match(uri)) {
-            case URI_NOTE:  // 查询笔记集合
+            case URI_NOTE:
                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                        sortOrder);
                break;
-
+            case URI_NOTE_ITEM:
            case URI_NOTE_ITEM:  // 查询单个笔记
                id = uri.getPathSegments().get(1);
                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
                break;
-            case URI_DATA:  // 查询笔记数据集合
+            case URI_DATA:
                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
                        sortOrder);
                break;
-            case URI_DATA_ITEM:  // 查询单个笔记数据
+            case URI_DATA_ITEM:
                id = uri.getPathSegments().get(1);
                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
                break;
-            case URI_SEARCH:  // 搜索请求
+            case URI_SEARCH:
-            case URI_SEARCH_SUGGEST:  // 搜索建议请求
+            case URI_SEARCH_SUGGEST:
                if (sortOrder != null || projection != null) {
                    throw new IllegalArgumentException(
                            "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
@ -183,27 +142,20 @@ public class NotesProvider extends ContentProvider {
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
        if (c != null) {
            // 通知游标所关联的 URI，用于后续数据变更时自动刷新
            c.setNotificationUri(getContext().getContentResolver(), uri);
        }
        return c;
    }
    /**
     * 插入方法 - 处理对笔记和数据的插入请求
     * @param uri 请求的URI
     * @param values 要插入的数据
     * @return 插入后的资源URI
     */
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        long dataId = 0, noteId = 0, insertedId = 0;
        switch (mMatcher.match(uri)) {
-            case URI_NOTE:  // 插入笔记
+            case URI_NOTE:
                insertedId = noteId = db.insert(TABLE.NOTE, null, values);
                break;
-            case URI_DATA:  // 插入笔记数据
+            case URI_DATA:
                if (values.containsKey(DataColumns.NOTE_ID)) {
                    noteId = values.getAsLong(DataColumns.NOTE_ID);
                } else {
@ -214,13 +166,13 @@ public class NotesProvider extends ContentProvider {
            default:
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
-        // 通知笔记 URI 变化（noteId>0 时）
+        // Notify the note uri
        if (noteId > 0) {
            getContext().getContentResolver().notifyChange(
                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
        }
-        // 通知数据 URI 变化（dataId>0 时）
+        // Notify the data uri
        if (dataId > 0) {
            getContext().getContentResolver().notifyChange(
                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
@ -229,13 +181,6 @@ public class NotesProvider extends ContentProvider {
        return ContentUris.withAppendedId(uri, insertedId);
    }
    /**
     * 删除方法 - 处理对笔记和数据的删除请求
     * @param uri 请求的URI
     * @param selection 删除条件
     * @param selectionArgs 删除条件参数
     * @return 删除的行数
     */
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int count = 0;
@ -252,7 +197,6 @@ public class NotesProvider extends ContentProvider {
                /**
                 * ID that smaller than 0 is system folder which is not allowed to
                 * trash
                 * ID小于0的是系统文件夹，不允许删除
                 */
                long noteId = Long.valueOf(id);
                if (noteId <= 0) {
@ -276,7 +220,6 @@ public class NotesProvider extends ContentProvider {
        }
        if (count > 0) {
            if (deleteData) {
                // 数据行删除会影响笔记摘要，通知笔记 URI
                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
            }
            getContext().getContentResolver().notifyChange(uri, null);
@ -284,37 +227,28 @@ public class NotesProvider extends ContentProvider {
        return count;
    }
    /**
     * 更新数据库中的数据
     * @param uri 要更新的内容URI
     * @param values 要更新的列值
     * @param selection 更新条件
     * @param selectionArgs 更新条件参数
     * @return 更新的行数
     */
    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        int count = 0;
        String id = null;
        SQLiteDatabase db = mHelper.getWritableDatabase();
-        boolean updateData = false;  // 是否更新了数据内容
+        boolean updateData = false;
        switch (mMatcher.match(uri)) {
-            case URI_NOTE:  // 更新所有笔记
+            case URI_NOTE:
-                increaseNoteVersion(-1, selection, selectionArgs);  // 增加笔记版本号
+                increaseNoteVersion(-1, selection, selectionArgs);
                count = db.update(TABLE.NOTE, values, selection, selectionArgs);
                break;
-            case URI_NOTE_ITEM:  // 更新单个笔记
+            case URI_NOTE_ITEM:
                id = uri.getPathSegments().get(1);
-                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);  // 增加笔记版本号
+                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
                count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs);
                break;
-            case URI_DATA:  // 更新所有笔记数据
+            case URI_DATA:
                count = db.update(TABLE.DATA, values, selection, selectionArgs);
                updateData = true;
                break;
-            case URI_DATA_ITEM:  // 更新单个笔记数据
+            case URI_DATA_ITEM:
                id = uri.getPathSegments().get(1);
                count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs);
@ -326,32 +260,17 @@ public class NotesProvider extends ContentProvider {
        if (count > 0) {
            if (updateData) {
                // 数据行更新影响笔记摘要，通知笔记 URI
                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
            }
            // 通知URI的观察者数据已更改
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return count;
    }
    /**
     * 拼接 WHERE 子句，如果传入 selection 非空则加上 AND (...)。
     *
     * @param selection 选择条件
     * @return 格式化后的选择条件
     */
    private String parseSelection(String selection) {
-        return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ")" : "");
+        return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
    }
    /**
     * 增加笔记版本号，用于标记被修改过。
     * 用于记录笔记的修改版本，支持并发更新场景
     * @param id 笔记ID；小于0表示不按ID过滤，仅使用 selection
     * @param selection 选择条件
     * @param selectionArgs 选择参数
     */
    private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
        StringBuilder sql = new StringBuilder(120);
        sql.append("UPDATE ");
@ -377,11 +296,6 @@ public class NotesProvider extends ContentProvider {
        mHelper.getWritableDatabase().execSQL(sql.toString());
    }
    /**
     * 获取内容URI对应的MIME类型
     * @param uri 内容URI
     * @return MIME类型 - 目前未完全实现，返回null
     */
    @Override
    public String getType(Uri uri) {
        // TODO Auto-generated method stub
--- a/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
@ -25,22 +25,11 @@ import org.json.JSONException;
 import org.json.JSONObject;
 /**
 * 元数据 - 继承自Task
 * 用于处理Google任务的元数据信息
 */
 public class MetaData extends Task {
    // 日志标签
    private final static String TAG = MetaData.class.getSimpleName();
    // 相关的Google任务ID
    private String mRelatedGid = null;
    /**
     * 设置元数据
     * @param gid Google任务ID
     * @param metaInfo 元信息JSON对象
     */
    public void setMeta(String gid, JSONObject metaInfo) {
        try {
            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
@ -51,27 +40,15 @@ public class MetaData extends Task {
        setName(GTaskStringUtils.META_NOTE_NAME);
    }
    /**
     * 获取相关的Google任务ID
     * @return 相关的Google任务ID
     */
    public String getRelatedGid() {
        return mRelatedGid;
    }
    /**
     * 判断是否值得保存
     * @return 如果有元信息则返回true，否则返回false
     */
    @Override
    public boolean isWorthSaving() {
        return getNotes() != null;
    }
    /**
     * 通过远程JSON设置内容
     * @param js 远程JSON对象
     */
    @Override
    public void setContentByRemoteJSON(JSONObject js) {
        super.setContentByRemoteJSON(js);
@ -86,33 +63,17 @@ public class MetaData extends Task {
        }
    }
    /**
     * 通过本地JSON设置内容
     * 该方法不应该被调用
     * @param js 本地JSON对象
     */
    @Override
    public void setContentByLocalJSON(JSONObject js) {
        // this function should not be called
        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
    }
    /**
     * 从内容获取本地JSON
     * 该方法不应该被调用
     * @return 本地JSON对象
     */
    @Override
    public JSONObject getLocalJSONFromContent() {
        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
    }
    /**
     * 获取同步操作
     * 该方法不应该被调用
     * @param c 游标
     * @return 同步操作类型
     */
    @Override
    public int getSyncAction(Cursor c) {
        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
--- a/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
@ -20,32 +20,33 @@ import android.database.Cursor;
 import org.json.JSONObject;
 /**
 * 同步节点抽象 - 定义了同步操作的基本结构和接口
 * 所有需要进行同步的对象都应该继承这个类
 */
 public abstract class Node {
-    // 同步操作类型常量
+    public static final int SYNC_ACTION_NONE = 0;
-    public static final int SYNC_ACTION_NONE = 0;              // 无操作
+
-    public static final int SYNC_ACTION_ADD_REMOTE = 1;        // 远程添加
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;
-    public static final int SYNC_ACTION_ADD_LOCAL = 2;         // 本地添加
+
-    public static final int SYNC_ACTION_DEL_REMOTE = 3;        // 远程删除
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;
-    public static final int SYNC_ACTION_DEL_LOCAL = 4;         // 本地删除
+
-    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;     // 远程更新
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;
-    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;      // 本地更新
+
-    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;   // 更新冲突
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;
-    public static final int SYNC_ACTION_ERROR = 8;             // 同步错误
+
-
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
-    // 成员变量
+
-    private String mGid;           // Google任务ID
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
-    private String mName;          // 节点名称
+
-    private long mLastModified;    // 最后修改时间戳
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
-    private boolean mDeleted;      // 是否已删除
+
-
+    public static final int SYNC_ACTION_ERROR = 8;
-    /**
+
-     * 构造函数
+    private String mGid;
-     * 初始化节点的基本属性
+
-     */
+    private String mName;
    private long mLastModified;
    private boolean mDeleted;
    public Node() {
        mGid = null;
        mName = "";
@ -53,105 +54,46 @@ public abstract class Node {
        mDeleted = false;
    }
    /**
     * 获取创建操作的JSON对象
     * @param actionId 操作ID
     * @return 创建操作的JSON对象
     */
    public abstract JSONObject getCreateAction(int actionId);
    /**
     * 获取更新操作的JSON对象
     * @param actionId 操作ID
     * @return 更新操作的JSON对象
     */
    public abstract JSONObject getUpdateAction(int actionId);
    /**
     * 通过远程JSON设置内容
     * @param js 远程JSON对象
     */
    public abstract void setContentByRemoteJSON(JSONObject js);
    /**
     * 通过本地JSON设置内容
     * @param js 本地JSON对象
     */
    public abstract void setContentByLocalJSON(JSONObject js);
    /**
     * 从内容获取本地JSON
     * @return 本地JSON对象
     */
    public abstract JSONObject getLocalJSONFromContent();
    /**
     * 获取同步操作类型
     * @param c 游标
     * @return 同步操作类型
     */
    public abstract int getSyncAction(Cursor c);
    /**
     * 设置Google任务ID
     * @param gid Google任务ID
     */
    public void setGid(String gid) {
        this.mGid = gid;
    }
    /**
     * 设置节点名称
     * @param name 节点名称
     */
    public void setName(String name) {
        this.mName = name;
    }
    /**
     * 设置最后修改时间
     * @param lastModified 最后修改时间戳
     */
    public void setLastModified(long lastModified) {
        this.mLastModified = lastModified;
    }
    /**
     * 设置删除状态
     * @param deleted 是否已删除
     */
    public void setDeleted(boolean deleted) {
        this.mDeleted = deleted;
    }
    /**
     * 获取Google任务ID
     * @return Google任务ID
     */
    public String getGid() {
        return this.mGid;
    }
    /**
     * 获取节点名称
     * @return 节点名称
     */
    public String getName() {
        return this.mName;
    }
    /**
     * 获取最后修改时间
     * @return 最后修改时间戳
     */
    public long getLastModified() {
        return this.mLastModified;
    }
    /**
     * 获取删除状态
     * @return 是否已删除
     */
    public boolean getDeleted() {
        return this.mDeleted;
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
@ -35,44 +35,42 @@ import org.json.JSONException;
 import org.json.JSONObject;
 /**
 * SQL数据处理 - 负责处理笔记数据的CRUD操作
 * 与ContentResolver交互，实现数据的加载、保存和更新
 */
 public class SqlData {
    // 日志标签
    private static final String TAG = SqlData.class.getSimpleName();
    // 无效ID常量
    private static final int INVALID_ID = -99999;
    // 数据查询投影
    public static final String[] PROJECTION_DATA = new String[] {
            DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
            DataColumns.DATA3
    };
-    // 投影列索引常量
+    public static final int DATA_ID_COLUMN = 0;
-    public static final int DATA_ID_COLUMN = 0;                    // 数据ID列
+
-    public static final int DATA_MIME_TYPE_COLUMN = 1;             // MIME类型列
+    public static final int DATA_MIME_TYPE_COLUMN = 1;
-    public static final int DATA_CONTENT_COLUMN = 2;               // 内容列
+
-    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;        // DATA1列
+    public static final int DATA_CONTENT_COLUMN = 2;
-    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;        // DATA3列
+
-
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
-    // 成员变量
+
-    private ContentResolver mContentResolver;  // 内容解析器
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
-    private boolean mIsCreate;                 // 是否为创建模式
+
-    private long mDataId;                      // 数据ID
+    private ContentResolver mContentResolver;
-    private String mDataMimeType;              // 数据MIME类型
+
-    private String mDataContent;               // 数据内容
+    private boolean mIsCreate;
-    private long mDataContentData1;            // DATA1字段值
+
-    private String mDataContentData3;          // DATA3字段值
+    private long mDataId;
-    private ContentValues mDiffDataValues;     // 差异数据值，用于更新操作
+
-
+    private String mDataMimeType;
-    /**
+
-     * 构造函数 - 创建新的数据对象
+    private String mDataContent;
-     * @param context 上下文对象
+
-     */
+    private long mDataContentData1;
    private String mDataContentData3;
    private ContentValues mDiffDataValues;
    public SqlData(Context context) {
        mContentResolver = context.getContentResolver();
        mIsCreate = true;
@ -84,11 +82,6 @@ public class SqlData {
        mDiffDataValues = new ContentValues();
    }
    /**
     * 构造函数 - 从数据库游标创建数据对象
     * @param context 上下文对象
     * @param c 数据库游标
     */
    public SqlData(Context context, Cursor c) {
        mContentResolver = context.getContentResolver();
        mIsCreate = false;
@ -96,10 +89,6 @@ public class SqlData {
        mDiffDataValues = new ContentValues();
    }
    /**
     * 从游标加载数据
     * @param c 数据库游标
     */
    private void loadFromCursor(Cursor c) {
        mDataId = c.getLong(DATA_ID_COLUMN);
        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@ -108,11 +97,6 @@ public class SqlData {
        mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
    }
    /**
     * 通过JSON对象设置数据内容
     * @param js JSON对象，包含数据内容
     * @throws JSONException JSON解析异常
     */
    public void setContent(JSONObject js) throws JSONException {
        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
        if (mIsCreate || mDataId != dataId) {
@ -146,11 +130,6 @@ public class SqlData {
        mDataContentData3 = dataContentData3;
    }
    /**
     * 获取数据内容的JSON对象
     * @return 包含数据内容的JSON对象
     * @throws JSONException JSON解析异常
     */
    public JSONObject getContent() throws JSONException {
        if (mIsCreate) {
            Log.e(TAG, "it seems that we haven't created this in database yet");
@ -165,13 +144,6 @@ public class SqlData {
        return js;
    }
    /**
     * 提交数据到数据库
     * @param noteId 笔记ID
     * @param validateVersion 是否验证版本
     * @param version 版本号
     * @throws ActionFailureException 操作失败异常
     */
    public void commit(long noteId, boolean validateVersion, long version) {
        if (mIsCreate) {
@ -211,10 +183,6 @@ public class SqlData {
        mIsCreate = false;
    }
    /**
     * 获取数据ID
     * @return 数据ID
     */
    public long getId() {
        return mDataId;
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
@ -38,21 +38,11 @@ import org.json.JSONObject;
 import java.util.ArrayList;
 /**
 * SqlNote - 用于管理笔记和相关数据的同步操作
 * 该类负责将笔记数据与 Google Tasks 进行同步，处理数据的创建、更新和删除操作
 */
 public class SqlNote {
    private static final String TAG = SqlNote.class.getSimpleName();
    /**
     * 无效ID常量 - 用于标记未创建或无效的笔记ID
     */
    private static final int INVALID_ID = -99999;
    /**
     * 笔记查询投影数组 - 定义从数据库查询笔记时返回的列
     */
    public static final String[] PROJECTION_NOTE = new String[] {
            NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
            NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@ -62,185 +52,76 @@ public class SqlNote {
            NoteColumns.VERSION
    };
    /**
     * 笔记ID列索引 - PROJECTION_NOTE数组中ID列的位置
     */
    public static final int ID_COLUMN = 0;
    /**
     * 提醒日期列索引 - PROJECTION_NOTE数组中提醒日期列的位置
     */
    public static final int ALERTED_DATE_COLUMN = 1;
    /**
     * 背景颜色ID列索引 - PROJECTION_NOTE数组中背景颜色ID列的位置
     */
    public static final int BG_COLOR_ID_COLUMN = 2;
    /**
     * 创建日期列索引 - PROJECTION_NOTE数组中创建日期列的位置
     */
    public static final int CREATED_DATE_COLUMN = 3;
    /**
     * 是否有附件列索引 - PROJECTION_NOTE数组中是否有附件列的位置
     */
    public static final int HAS_ATTACHMENT_COLUMN = 4;
    /**
     * 修改日期列索引 - PROJECTION_NOTE数组中修改日期列的位置
     */
    public static final int MODIFIED_DATE_COLUMN = 5;
    /**
     * 笔记数量列索引 - PROJECTION_NOTE数组中笔记数量列的位置
     */
    public static final int NOTES_COUNT_COLUMN = 6;
    /**
     * 父文件夹ID列索引 - PROJECTION_NOTE数组中父文件夹ID列的位置
     */
    public static final int PARENT_ID_COLUMN = 7;
    /**
     * 笔记摘要列索引 - PROJECTION_NOTE数组中笔记摘要列的位置
     */
    public static final int SNIPPET_COLUMN = 8;
    /**
     * 笔记类型列索引 - PROJECTION_NOTE数组中笔记类型列的位置
     */
    public static final int TYPE_COLUMN = 9;
    /**
     * 小部件ID列索引 - PROJECTION_NOTE数组中小部件ID列的位置
     */
    public static final int WIDGET_ID_COLUMN = 10;
    /**
     * 小部件类型列索引 - PROJECTION_NOTE数组中小部件类型列的位置
     */
    public static final int WIDGET_TYPE_COLUMN = 11;
    /**
     * 同步ID列索引 - PROJECTION_NOTE数组中同步ID列的位置
     */
    public static final int SYNC_ID_COLUMN = 12;
    /**
     * 本地修改状态列索引 - PROJECTION_NOTE数组中本地修改状态列的位置
     */
    public static final int LOCAL_MODIFIED_COLUMN = 13;
    /**
     * 原始父文件夹ID列索引 - PROJECTION_NOTE数组中原始父文件夹ID列的位置
     */
    public static final int ORIGIN_PARENT_ID_COLUMN = 14;
    /**
     * Google Tasks ID列索引 - PROJECTION_NOTE数组中Google Tasks ID列的位置
     */
    public static final int GTASK_ID_COLUMN = 15;
    /**
     * 版本号列索引 - PROJECTION_NOTE数组中版本号列的位置
     */
    public static final int VERSION_COLUMN = 16;
    /**
     * 上下文对象 - 用于访问应用资源和内容解析器
     */
    private Context mContext;
    /**
     * 内容解析器 - 用于访问ContentProvider进行数据操作
     */
    private ContentResolver mContentResolver;
    /**
     * 创建标志 - 标记笔记是否为新创建（未保存到数据库）
     */
    private boolean mIsCreate;
    /**
     * 笔记ID - 唯一标识一个笔记
     */
    private long mId;
    /**
     * 提醒日期 - 笔记的提醒时间戳
     */
    private long mAlertDate;
    /**
     * 背景颜色ID - 笔记的背景颜色资源ID
     */
    private int mBgColorId;
    /**
     * 创建日期 - 笔记创建的时间戳
     */
    private long mCreatedDate;
    /**
     * 是否有附件 - 标记笔记是否包含附件（0表示无，1表示有）
     */
    private int mHasAttachment;
    /**
     * 修改日期 - 笔记最后修改的时间戳
     */
    private long mModifiedDate;
    /**
     * 父文件夹ID - 笔记所属文件夹的ID
     */
    private long mParentId;
    /**
     * 笔记摘要 - 笔记内容的简短描述
     */
    private String mSnippet;
    /**
     * 笔记类型 - 区分笔记、文件夹、系统文件夹等类型
     */
    private int mType;
    /**
     * 小部件ID - 关联的应用小部件ID
     */
    private int mWidgetId;
    /**
     * 小部件类型 - 关联的应用小部件类型
     */
    private int mWidgetType;
    /**
     * 原始父文件夹ID - 笔记原始所属文件夹的ID（用于移动操作）
     */
    private long mOriginParent;
    /**
     * 版本号 - 用于处理并发编辑和同步冲突
     */
    private long mVersion;
    /**
     * 差异内容值 - 存储笔记属性的变更，用于数据库更新
     */
    private ContentValues mDiffNoteValues;
    /**
     * 数据列表 - 存储与笔记关联的详细内容数据
     */
    private ArrayList<SqlData> mDataList;
    /**
     * 构造函数 - 创建一个新的笔记对象
     * @param context 上下文对象
     */
    public SqlNote(Context context) {
        mContext = context;
        mContentResolver = context.getContentResolver();
@ -262,11 +143,6 @@ public class SqlNote {
        mDataList = new ArrayList<SqlData>();
    }
    /**
     * 构造函数 - 从数据库游标创建笔记对象
     * @param context 上下文对象
     * @param c 包含笔记数据的数据库游标
     */
    public SqlNote(Context context, Cursor c) {
        mContext = context;
        mContentResolver = context.getContentResolver();
@ -278,11 +154,6 @@ public class SqlNote {
        mDiffNoteValues = new ContentValues();
    }
    /**
     * 构造函数 - 根据笔记ID创建笔记对象
     * @param context 上下文对象
     * @param id 笔记ID
     */
    public SqlNote(Context context, long id) {
        mContext = context;
        mContentResolver = context.getContentResolver();
@ -292,12 +163,9 @@ public class SqlNote {
        if (mType == Notes.TYPE_NOTE)
            loadDataContent();
        mDiffNoteValues = new ContentValues();
    }
    /**
     * 根据ID从数据库加载笔记数据
     * @param id 笔记ID
     */
    private void loadFromCursor(long id) {
        Cursor c = null;
        try {
@ -317,10 +185,6 @@ public class SqlNote {
        }
    }
    /**
     * 从数据库游标加载笔记数据
     * @param c 包含笔记数据的游标
     */
    private void loadFromCursor(Cursor c) {
        mId = c.getLong(ID_COLUMN);
        mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -336,10 +200,6 @@ public class SqlNote {
        mVersion = c.getLong(VERSION_COLUMN);
    }
    /**
     * 加载笔记关联的数据内容
     * 从数据库查询与当前笔记关联的所有数据项
     */
    private void loadDataContent() {
        Cursor c = null;
        mDataList.clear();
@ -366,19 +226,13 @@ public class SqlNote {
        }
    }
    /**
     * 从JSON对象设置笔记内容
     * @param js 包含笔记数据的JSON对象
     * @return 设置成功返回true，失败返回false
     */
    public boolean setContent(JSONObject js) {
        try {
            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
            if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
                // 系统文件夹不允许修改
                Log.w(TAG, "cannot set system folder");
            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
-                // 对于文件夹，只能更新摘要和类型
+                // for folder we can only update the snnipet and type
                String snippet = note.has(NoteColumns.SNIPPET) ? note
                        .getString(NoteColumns.SNIPPET) : "";
                if (mIsCreate || !mSnippet.equals(snippet)) {
@ -393,7 +247,6 @@ public class SqlNote {
                }
                mType = type;
            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
                // 对于普通笔记，更新所有属性并处理关联数据
                JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
                long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
                if (mIsCreate || mId != id) {
@ -478,11 +331,9 @@ public class SqlNote {
                }
                mOriginParent = originParent;
                // 处理关联的数据项
                for (int i = 0; i < dataArray.length(); i++) {
                    JSONObject data = dataArray.getJSONObject(i);
                    SqlData sqlData = null;
                    // 查找是否已存在相同ID的数据项
                    if (data.has(DataColumns.ID)) {
                        long dataId = data.getLong(DataColumns.ID);
                        for (SqlData temp : mDataList) {
@ -492,13 +343,11 @@ public class SqlNote {
                        }
                    }
                    // 如果不存在，则创建新的数据项
                    if (sqlData == null) {
                        sqlData = new SqlData(mContext);
                        mDataList.add(sqlData);
                    }
                    // 设置数据项内容
                    sqlData.setContent(data);
                }
            }
@ -510,23 +359,17 @@ public class SqlNote {
        return true;
    }
    /**
     * 将笔记内容转换为JSON对象
     * @return 包含笔记数据的JSON对象，未创建的笔记返回null
     */
    public JSONObject getContent() {
        try {
            JSONObject js = new JSONObject();
            if (mIsCreate) {
                // 未保存到数据库的笔记无法获取完整内容
                Log.e(TAG, "it seems that we haven't created this in database yet");
                return null;
            }
            JSONObject note = new JSONObject();
            if (mType == Notes.TYPE_NOTE) {
                // 普通笔记包含所有属性和关联数据
                note.put(NoteColumns.ID, mId);
                note.put(NoteColumns.ALERTED_DATE, mAlertDate);
                note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@ -541,7 +384,6 @@ public class SqlNote {
                note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
                // 添加关联的数据项
                JSONArray dataArray = new JSONArray();
                for (SqlData sqlData : mDataList) {
                    JSONObject data = sqlData.getContent();
@ -551,7 +393,6 @@ public class SqlNote {
                }
                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
            } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
                // 文件夹和系统文件夹只包含基本属性
                note.put(NoteColumns.ID, mId);
                note.put(NoteColumns.TYPE, mType);
                note.put(NoteColumns.SNIPPET, mSnippet);
@ -566,87 +407,47 @@ public class SqlNote {
        return null;
    }
    /**
     * 设置笔记的父文件夹ID
     * @param id 父文件夹ID
     */
    public void setParentId(long id) {
        mParentId = id;
        mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
    }
    /**
     * 设置Google Tasks ID
     * @param gid Google Tasks ID
     */
    public void setGtaskId(String gid) {
        mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
    }
    /**
     * 设置同步ID
     * @param syncId 同步ID
     */
    public void setSyncId(long syncId) {
        mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
    }
    /**
     * 重置本地修改状态
     * 将本地修改标记设置为0，表示没有本地修改
     */
    public void resetLocalModified() {
        mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
    }
    /**
     * 获取笔记ID
     * @return 笔记ID
     */
    public long getId() {
        return mId;
    }
    /**
     * 获取父文件夹ID
     * @return 父文件夹ID
     */
    public long getParentId() {
        return mParentId;
    }
    /**
     * 获取笔记摘要
     * @return 笔记摘要
     */
    public String getSnippet() {
        return mSnippet;
    }
    /**
     * 判断是否为笔记类型
     * @return 是笔记类型返回true，否则返回false
     */
    public boolean isNoteType() {
        return mType == Notes.TYPE_NOTE;
    }
    /**
     * 将笔记提交到数据库
     * @param validateVersion 是否验证版本号（用于处理并发编辑）
     */
    public void commit(boolean validateVersion) {
        if (mIsCreate) {
            // 创建新笔记
            // 如果ID无效且包含ID字段，则移除该字段（由数据库自动生成）
            if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
                mDiffNoteValues.remove(NoteColumns.ID);
            }
            // 插入新笔记到数据库
            Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
            try {
                // 从返回的URI中提取新生成的笔记ID
                mId = Long.valueOf(uri.getPathSegments().get(1));
            } catch (NumberFormatException e) {
                Log.e(TAG, "Get note id error :" + e.toString());
@ -656,32 +457,25 @@ public class SqlNote {
                throw new IllegalStateException("Create thread id failed");
            }
            // 如果是普通笔记，提交关联的数据项
            if (mType == Notes.TYPE_NOTE) {
                for (SqlData sqlData : mDataList) {
                    sqlData.commit(mId, false, -1);
                }
            }
        } else {
            // 更新现有笔记
            // 验证笔记ID的有效性（根文件夹和通话记录文件夹是特殊情况）
            if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
                Log.e(TAG, "No such note");
                throw new IllegalStateException("Try to update note with invalid id");
            }
            // 如果有需要更新的字段
            if (mDiffNoteValues.size() > 0) {
-                mVersion ++; // 版本号递增
+                mVersion ++;
                int result = 0;
                if (!validateVersion) {
                    // 不验证版本号，直接更新
                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
                            + NoteColumns.ID + "=?)", new String[] {
                        String.valueOf(mId)
                    });
                } else {
                    // 验证版本号，确保不会覆盖并发编辑
                    result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
                            + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
                            new String[] {
@ -693,7 +487,6 @@ public class SqlNote {
                }
            }
            // 如果是普通笔记，提交关联的数据项
            if (mType == Notes.TYPE_NOTE) {
                for (SqlData sqlData : mDataList) {
                    sqlData.commit(mId, validateVersion, mVersion);
@ -701,12 +494,11 @@ public class SqlNote {
            }
        }
-        // 刷新本地信息，确保与数据库保持一致
+        // refresh local info
        loadFromCursor(mId);
        if (mType == Notes.TYPE_NOTE)
            loadDataContent();
        // 清除差异内容值并标记为已创建
        mDiffNoteValues.clear();
        mIsCreate = false;
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
@ -32,91 +32,64 @@ import org.json.JSONException;
 import org.json.JSONObject;
 /**
 * Task - 表示Google Tasks中的一个任务
 * 继承自Node类，扩展了任务特定的功能
 */
 public class Task extends Node {
    private static final String TAG = Task.class.getSimpleName();
    /**
     * 完成状态 - 标记任务是否已完成
     */
    private boolean mCompleted;
    /**
     * 任务备注 - 任务的详细描述或备注信息
     */
    private String mNotes;
    /**
     * 元信息 - 包含任务的额外信息的JSON对象
     */
    private JSONObject mMetaInfo;
    /**
     * 前一个兄弟任务 - 任务在父列表中的前一个任务
     */
    private Task mPriorSibling;
    /**
     * 父任务列表 - 任务所属的任务列表
     */
    private TaskList mParent;
    /**
     * 构造函数 - 初始化一个新的任务对象
     */
    public Task() {
        super();
-        mCompleted = false; // 默认未完成
+        mCompleted = false;
-        mNotes = null; // 默认无备注
+        mNotes = null;
-        mPriorSibling = null; // 默认无前一个兄弟任务
+        mPriorSibling = null;
-        mParent = null; // 默认无父任务列表
+        mParent = null;
-        mMetaInfo = null; // 默认无元信息
+        mMetaInfo = null;
    }
    /**
     * 获取创建任务的操作JSON对象
     * @param actionId 操作ID
     * @return 包含创建任务操作信息的JSON对象
     */
    public JSONObject getCreateAction(int actionId) {
        JSONObject js = new JSONObject();
        try {
-            // 设置操作类型为创建
+            // action_type
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
-            // 设置操作ID
+            // action_id
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
-            // 设置任务在父列表中的索引位置
+            // index
            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
-            // 设置任务实体信息
+            // entity_delta
            JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务名称
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
-            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
-                    GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 实体类型为任务
+                    GTaskStringUtils.GTASK_JSON_TYPE_TASK);
            if (getNotes() != null) {
-                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 任务备注（如果有）
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
            }
            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
-            // 设置父任务列表ID
+            // parent_id
            js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
-            // 设置目标父类型为组
+            // dest_parent_type
            js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
-            // 设置列表ID
+            // list_id
            js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
-            // 设置前一个兄弟任务ID（如果有）
+            // prior_sibling_id
            if (mPriorSibling != null) {
                js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
            }
@ -130,32 +103,27 @@ public class Task extends Node {
        return js;
    }
    /**
     * 获取更新任务的操作JSON对象
     * @param actionId 操作ID
     * @return 包含更新任务操作信息的JSON对象
     */
    public JSONObject getUpdateAction(int actionId) {
        JSONObject js = new JSONObject();
        try {
-            // 设置操作类型为更新
+            // action_type
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
-            // 设置操作ID
+            // action_id
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
-            // 设置任务ID
+            // id
            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
-            // 设置要更新的实体信息
+            // entity_delta
            JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 更新任务名称
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
            if (getNotes() != null) {
-                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 更新任务备注（如果有）
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
            }
-            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 更新删除状态
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
        } catch (JSONException e) {
@ -167,39 +135,35 @@ public class Task extends Node {
        return js;
    }
    /**
     * 从远程JSON对象设置任务内容
     * @param js 包含远程任务数据的JSON对象
     */
    public void setContentByRemoteJSON(JSONObject js) {
        if (js != null) {
            try {
-                // 设置任务ID
+                // id
                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                }
-                // 设置最后修改时间
+                // last_modified
                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                }
-                // 设置任务名称
+                // name
                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                }
-                // 设置任务备注
+                // notes
                if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
                    setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
                }
-                // 设置删除状态
+                // deleted
                if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
                    setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
                }
-                // 设置完成状态
+                // completed
                if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
                    setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
                }
@ -211,28 +175,21 @@ public class Task extends Node {
        }
    }
    /**
     * 从本地JSON对象设置任务内容
     * @param js 包含本地笔记数据的JSON对象
     */
    public void setContentByLocalJSON(JSONObject js) {
        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
                || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
            return;
        }
        try {
            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
            JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
            // 确保是普通笔记类型
            if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
                Log.e(TAG, "invalid type");
                return;
            }
            // 查找并设置笔记内容作为任务名称
            for (int i = 0; i < dataArray.length(); i++) {
                JSONObject data = dataArray.getJSONObject(i);
                if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
@ -247,37 +204,31 @@ public class Task extends Node {
        }
    }
    /**
     * 从任务内容生成本地JSON对象
     * @return 包含本地笔记数据的JSON对象
     */
    public JSONObject getLocalJSONFromContent() {
        String name = getName();
        try {
            if (mMetaInfo == null) {
-                // 从网络创建的新任务
+                // new task created from web
                if (name == null) {
                    Log.w(TAG, "the note seems to be an empty one");
                    return null;
                }
                // 创建新的JSON对象结构
                JSONObject js = new JSONObject();
                JSONObject note = new JSONObject();
                JSONArray dataArray = new JSONArray();
                JSONObject data = new JSONObject();
-                data.put(DataColumns.CONTENT, name); // 设置笔记内容为任务名称
+                data.put(DataColumns.CONTENT, name);
                dataArray.put(data);
-                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 添加数据数组
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
-                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置笔记类型为普通笔记
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
-                js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 添加笔记对象
+                js.put(GTaskStringUtils.META_HEAD_NOTE, note);
                return js;
            } else {
-                // 已同步的任务
+                // synced task
                JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
                JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
                // 更新笔记内容为当前任务名称
                for (int i = 0; i < dataArray.length(); i++) {
                    JSONObject data = dataArray.getJSONObject(i);
                    if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
@ -286,7 +237,7 @@ public class Task extends Node {
                    }
                }
-                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 确保笔记类型为普通笔记
+                note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
                return mMetaInfo;
            }
        } catch (JSONException e) {
@ -296,14 +247,9 @@ public class Task extends Node {
        }
    }
    /**
     * 设置任务的元信息
     * @param metaData 包含元信息的MetaData对象
     */
    public void setMetaInfo(MetaData metaData) {
        if (metaData != null && metaData.getNotes() != null) {
            try {
                // 从元数据中解析JSON对象
                mMetaInfo = new JSONObject(metaData.getNotes());
            } catch (JSONException e) {
                Log.w(TAG, e.toString());
@ -312,11 +258,6 @@ public class Task extends Node {
        }
    }
    /**
     * 确定任务的同步操作类型
     * @param c 包含本地笔记数据的游标
     * @return 同步操作类型：SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_REMOTE或SYNC_ACTION_ERROR
     */
    public int getSyncAction(Cursor c) {
        try {
            JSONObject noteInfo = null;
@ -325,43 +266,40 @@ public class Task extends Node {
            }
            if (noteInfo == null) {
                // 元信息已删除，更新远程
                Log.w(TAG, "it seems that note meta has been deleted");
                return SYNC_ACTION_UPDATE_REMOTE;
            }
            if (!noteInfo.has(NoteColumns.ID)) {
                // 远程笔记ID已删除，更新本地
                Log.w(TAG, "remote note id seems to be deleted");
                return SYNC_ACTION_UPDATE_LOCAL;
            }
-            // 验证笔记ID
+            // validate the note id now
            if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
                Log.w(TAG, "note id doesn't match");
                return SYNC_ACTION_UPDATE_LOCAL;
            }
            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-                // 本地没有更新
+                // there is no local update
                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // 双方都没有更新
+                    // no update both side
                    return SYNC_ACTION_NONE;
                } else {
-                    // 将远程更新应用到本地
+                    // apply remote to local
                    return SYNC_ACTION_UPDATE_LOCAL;
                }
            } else {
-                // 本地有更新，验证Google Tasks ID
+                // validate gtask id
                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                    Log.e(TAG, "gtask id doesn't match");
                    return SYNC_ACTION_ERROR;
                }
                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // 只有本地更新
+                    // local modification only
                    return SYNC_ACTION_UPDATE_REMOTE;
                } else {
                    // 本地和远程都有更新，存在冲突
                    return SYNC_ACTION_UPDATE_CONFLICT;
                }
            }
@ -373,75 +311,39 @@ public class Task extends Node {
        return SYNC_ACTION_ERROR;
    }
    /**
     * 判断任务是否值得保存
     * @return 任务有元信息、非空名称或非空备注时返回true，否则返回false
     */
    public boolean isWorthSaving() {
        return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
                || (getNotes() != null && getNotes().trim().length() > 0);
    }
    /**
     * 设置任务的完成状态
     * @param completed 完成状态
     */
    public void setCompleted(boolean completed) {
        this.mCompleted = completed;
    }
    /**
     * 设置任务的备注
     * @param notes 任务备注
     */
    public void setNotes(String notes) {
        this.mNotes = notes;
    }
    /**
     * 设置任务的前一个兄弟任务
     * @param priorSibling 前一个兄弟任务
     */
    public void setPriorSibling(Task priorSibling) {
        this.mPriorSibling = priorSibling;
    }
    /**
     * 设置任务的父任务列表
     * @param parent 父任务列表
     */
    public void setParent(TaskList parent) {
        this.mParent = parent;
    }
    /**
     * 获取任务的完成状态
     * @return 完成状态
     */
    public boolean getCompleted() {
        return this.mCompleted;
    }
    /**
     * 获取任务的备注
     * @return 任务备注
     */
    public String getNotes() {
        return this.mNotes;
    }
    /**
     * 获取任务的前一个兄弟任务
     * @return 前一个兄弟任务
     */
    public Task getPriorSibling() {
        return this.mPriorSibling;
    }
    /**
     * 获取任务的父任务列表
     * @return 父任务列表
     */
    public TaskList getParent() {
        return this.mParent;
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
@ -30,57 +30,39 @@ import org.json.JSONObject;
 import java.util.ArrayList;
 /**
 * TaskList - 表示Google Tasks中的一个任务列表
 * 继承自Node类，包含任务列表的基本信息和子任务
 */
 public class TaskList extends Node {
    private static final String TAG = TaskList.class.getSimpleName();
    /**
     * 索引 - 任务列表在父容器中的位置
     */
    private int mIndex;
    /**
     * 子任务列表 - 存储任务列表中的所有任务
     */
    private ArrayList<Task> mChildren;
    /**
     * 构造函数 - 初始化一个新的任务列表对象
     */
    public TaskList() {
        super();
-        mChildren = new ArrayList<Task>(); // 初始化子任务列表
+        mChildren = new ArrayList<Task>();
-        mIndex = 1; // 默认索引为1
+        mIndex = 1;
    }
    /**
     * 获取创建任务列表的操作JSON对象
     * @param actionId 操作ID
     * @return 包含创建任务列表操作信息的JSON对象
     */
    public JSONObject getCreateAction(int actionId) {
        JSONObject js = new JSONObject();
        try {
-            // 设置操作类型为创建
+            // action_type
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
-            // 设置操作ID
+            // action_id
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
-            // 设置任务列表索引
+            // index
            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
-            // 设置任务列表实体信息
+            // entity_delta
            JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务列表名称
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
-            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
-                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 实体类型为组
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
        } catch (JSONException e) {
@ -92,29 +74,24 @@ public class TaskList extends Node {
        return js;
    }
    /**
     * 获取更新任务列表的操作JSON对象
     * @param actionId 操作ID
     * @return 包含更新任务列表操作信息的JSON对象
     */
    public JSONObject getUpdateAction(int actionId) {
        JSONObject js = new JSONObject();
        try {
-            // 设置操作类型为更新
+            // action_type
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                    GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
-            // 设置操作ID
+            // action_id
            js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
-            // 设置任务列表ID
+            // id
            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
-            // 设置要更新的实体信息
+            // entity_delta
            JSONObject entity = new JSONObject();
-            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 更新任务列表名称
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
-            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 更新删除状态
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
        } catch (JSONException e) {
@ -126,24 +103,20 @@ public class TaskList extends Node {
        return js;
    }
    /**
     * 从远程JSON对象设置任务列表内容
     * @param js 包含远程任务列表数据的JSON对象
     */
    public void setContentByRemoteJSON(JSONObject js) {
        if (js != null) {
            try {
-                // 设置任务列表ID
+                // id
                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                }
-                // 设置最后修改时间
+                // last_modified
                if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                    setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                }
-                // 设置任务列表名称
+                // name
                if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                    setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                }
@ -156,26 +129,18 @@ public class TaskList extends Node {
        }
    }
    /**
     * 从本地JSON对象设置任务列表内容
     * @param js 包含本地文件夹数据的JSON对象
     */
    public void setContentByLocalJSON(JSONObject js) {
        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
            return;
        }
        try {
            JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
            // 根据本地文件夹类型设置任务列表名称
            if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
                // 普通文件夹，添加前缀
                String name = folder.getString(NoteColumns.SNIPPET);
                setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
            } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
                // 系统文件夹，根据ID设置不同名称
                if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
                else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
@ -192,30 +157,21 @@ public class TaskList extends Node {
        }
    }
    /**
     * 从任务列表内容生成本地JSON对象
     * @return 包含本地文件夹数据的JSON对象
     */
    public JSONObject getLocalJSONFromContent() {
        try {
            JSONObject js = new JSONObject();
            JSONObject folder = new JSONObject();
            // 移除任务列表名称的前缀
            String folderName = getName();
            if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
                folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
                        folderName.length());
            // 设置文件夹名称
            folder.put(NoteColumns.SNIPPET, folderName);
            // 根据名称设置文件夹类型
            if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
                    || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
-                folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 系统文件夹
+                folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
            else
-                folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 普通文件夹
+                folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
            js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
@ -227,33 +183,28 @@ public class TaskList extends Node {
        }
    }
    /**
     * 确定任务列表的同步操作类型
     * @param c 包含本地文件夹数据的游标
     * @return 同步操作类型：SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_REMOTE或SYNC_ACTION_ERROR
     */
    public int getSyncAction(Cursor c) {
        try {
            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-                // 本地没有更新
+                // there is no local update
                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // 双方都没有更新
+                    // no update both side
                    return SYNC_ACTION_NONE;
                } else {
-                    // 将远程更新应用到本地
+                    // apply remote to local
                    return SYNC_ACTION_UPDATE_LOCAL;
                }
            } else {
-                // 本地有更新，验证Google Tasks ID
+                // validate gtask id
                if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                    Log.e(TAG, "gtask id doesn't match");
                    return SYNC_ACTION_ERROR;
                }
                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // 只有本地更新
+                    // local modification only
                    return SYNC_ACTION_UPDATE_REMOTE;
                } else {
-                    // 对于文件夹冲突，直接应用本地修改
+                    // for folder conflicts, just apply local modification
                    return SYNC_ACTION_UPDATE_REMOTE;
                }
            }
@ -265,25 +216,16 @@ public class TaskList extends Node {
        return SYNC_ACTION_ERROR;
    }
    /**
     * 获取子任务数量
     * @return 子任务数量
     */
    public int getChildTaskCount() {
        return mChildren.size();
    }
    /**
     * 添加子任务到列表末尾
     * @param task 要添加的任务
     * @return 添加成功返回true，失败返回false
     */
    public boolean addChildTask(Task task) {
        boolean ret = false;
        if (task != null && !mChildren.contains(task)) {
            ret = mChildren.add(task);
            if (ret) {
-                // 设置前一个兄弟任务和父任务
+                // need to set prior sibling and parent
                task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
                        .get(mChildren.size() - 1));
                task.setParent(this);
@ -292,12 +234,6 @@ public class TaskList extends Node {
        return ret;
    }
    /**
     * 在指定位置添加子任务
     * @param task 要添加的任务
     * @param index 添加位置的索引
     * @return 添加成功返回true，失败返回false
     */
    public boolean addChildTask(Task task, int index) {
        if (index < 0 || index > mChildren.size()) {
            Log.e(TAG, "add child task: invalid index");
@ -308,7 +244,7 @@ public class TaskList extends Node {
        if (task != null && pos == -1) {
            mChildren.add(index, task);
-            // 更新任务列表的兄弟关系
+            // update the task list
            Task preTask = null;
            Task afterTask = null;
            if (index != 0)
@ -324,11 +260,6 @@ public class TaskList extends Node {
        return true;
    }
    /**
     * 移除子任务
     * @param task 要移除的任务
     * @return 移除成功返回true，失败返回false
     */
    public boolean removeChildTask(Task task) {
        boolean ret = false;
        int index = mChildren.indexOf(task);
@ -336,11 +267,11 @@ public class TaskList extends Node {
            ret = mChildren.remove(task);
            if (ret) {
-                // 重置前一个兄弟任务和父任务
+                // reset prior sibling and parent
                task.setPriorSibling(null);
                task.setParent(null);
-                // 更新任务列表的兄弟关系
+                // update the task list
                if (index != mChildren.size()) {
                    mChildren.get(index).setPriorSibling(
                            index == 0 ? null : mChildren.get(index - 1));
@ -350,13 +281,8 @@ public class TaskList extends Node {
        return ret;
    }
    /**
     * 移动子任务到新位置
     * @param task 要移动的任务
     * @param index 新位置的索引
     * @return 移动成功返回true，失败返回false
     */
    public boolean moveChildTask(Task task, int index) {
        if (index < 0 || index >= mChildren.size()) {
            Log.e(TAG, "move child task: invalid index");
            return false;
@ -373,11 +299,6 @@ public class TaskList extends Node {
        return (removeChildTask(task) && addChildTask(task, index));
    }
    /**
     * 根据Google Tasks ID查找子任务
     * @param gid Google Tasks ID
     * @return 找到的任务，未找到返回null
     */
    public Task findChildTaskByGid(String gid) {
        for (int i = 0; i < mChildren.size(); i++) {
            Task t = mChildren.get(i);
@ -388,20 +309,10 @@ public class TaskList extends Node {
        return null;
    }
    /**
     * 获取子任务在列表中的索引位置
     * @param task 子任务
     * @return 子任务的索引位置
     */
    public int getChildTaskIndex(Task task) {
        return mChildren.indexOf(task);
    }
    /**
     * 根据索引位置获取子任务
     * @param index 索引位置
     * @return 找到的任务，索引无效返回null
     */
    public Task getChildTaskByIndex(int index) {
        if (index < 0 || index >= mChildren.size()) {
            Log.e(TAG, "getTaskByIndex: invalid index");
@ -410,11 +321,6 @@ public class TaskList extends Node {
        return mChildren.get(index);
    }
    /**
     * 根据Google Tasks ID获取子任务
     * @param gid Google Tasks ID
     * @return 找到的任务，未找到返回null
     */
    public Task getChilTaskByGid(String gid) {
        for (Task task : mChildren) {
            if (task.getGid().equals(gid))
@ -423,26 +329,14 @@ public class TaskList extends Node {
        return null;
    }
    /**
     * 获取所有子任务的列表
     * @return 子任务列表
     */
    public ArrayList<Task> getChildTaskList() {
        return this.mChildren;
    }
    /**
     * 设置任务列表的索引
     * @param index 索引值
     */
    public void setIndex(int index) {
        this.mIndex = index;
    }
    /**
     * 获取任务列表的索引
     * @return 索引值
     */
    public int getIndex() {
        return this.mIndex;
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
@ -16,33 +16,17 @@
 package net.micode.notes.gtask.exception;
 /**
 * 操作失败异常，用于表示Google Tasks同步操作失败的情况
 */
 public class ActionFailureException extends RuntimeException {
    /** 序列化版本UID */
    private static final long serialVersionUID = 4425249765923293627L;
    /**
     * 默认构造方法
     */
    public ActionFailureException() {
        super();
    }
    /**
     * 带错误消息的构造方法
     * @param paramString 错误消息
     */
    public ActionFailureException(String paramString) {
        super(paramString);
    }
    /**
     * 带错误消息和原因的构造方法
     * @param paramString 错误消息
     * @param paramThrowable 异常原因
     */
    public ActionFailureException(String paramString, Throwable paramThrowable) {
        super(paramString, paramThrowable);
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
@ -16,33 +16,17 @@
 package net.micode.notes.gtask.exception;
 /**
 * 网络失败异常，用于表示Google Tasks同步过程中网络连接失败的情况
 */
 public class NetworkFailureException extends Exception {
    /** 序列化版本UID */
    private static final long serialVersionUID = 2107610287180234136L;
    /**
     * 默认构造方法
     */
    public NetworkFailureException() {
        super();
    }
    /**
     * 带错误消息的构造方法
     * @param paramString 错误消息
     */
    public NetworkFailureException(String paramString) {
        super(paramString);
    }
    /**
     * 带错误消息和原因的构造方法
     * @param paramString 错误消息
     * @param paramThrowable 异常原因
     */
    public NetworkFailureException(String paramString, Throwable paramThrowable) {
        super(paramString, paramThrowable);
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
@ -29,51 +29,22 @@ import net.micode.notes.ui.NotesListActivity;
 import net.micode.notes.ui.NotesPreferenceActivity;
 /**
 * GTaskASyncTask- 用于在后台执行Google Tasks同步操作的异步任务
 */
 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
    /**
     * 同步通知ID常量 - 用于标识Google Tasks同步通知
     */
    private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
    /**
     * OnCompleteListener接口 - 同步完成时的回调接口
     */
    public interface OnCompleteListener {
        /**
         * 同步完成时调用
         */
        void onComplete();
    }
    /**
     * 上下文对象 - 用于访问系统服务和资源
     */
    private Context mContext;
    /**
     * 通知管理器 - 用于显示同步通知
     */
    private NotificationManager mNotifiManager;
    /**
     * 任务管理器 - 用于执行实际的同步操作
     */
    private GTaskManager mTaskManager;
    /**
     * 完成监听器 - 同步完成时的回调对象
     */
    private OnCompleteListener mOnCompleteListener;
    /**
     * 构造函数 - 初始化Google Tasks异步任务
     * @param context 上下文对象
     * @param listener 同步完成时的回调监听器
     */
    public GTaskASyncTask(Context context, OnCompleteListener listener) {
        mContext = context;
        mOnCompleteListener = listener;
@ -82,70 +53,35 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
        mTaskManager = GTaskManager.getInstance();
    }
    /**
     * 取消同步操作
     */
    public void cancelSync() {
        mTaskManager.cancelSync();
    }
    /**
     * 发布同步进度
     * @param message 进度消息
     */
    public void publishProgess(String message) {
        publishProgress(new String[] {
            message
        });
    }
    //private void showNotification(int tickerId, String content) {
    //    Notification notification = new Notification(R.drawable.notification, mContext
    //            .getString(tickerId), System.currentTimeMillis());
    //    notification.defaults = Notification.DEFAULT_LIGHTS;
    //    notification.flags = Notification.FLAG_AUTO_CANCEL;
    //   PendingIntent pendingIntent;
    //    if (tickerId != R.string.ticker_success) {
    //      pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
    //                NotesPreferenceActivity.class), 0);
    //
    //    } else {
    //        pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
    //                NotesListActivity.class), 0);
    //    }
    //    notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
    //            pendingIntent);
    //    mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
    //}
    /**
     * 显示同步通知
     * @param tickerId 通知标题的字符串资源ID
     * @param content 通知内容
     */
    private void showNotification(int tickerId, String content) {
        Notification notification = new Notification(R.drawable.notification, mContext
                .getString(tickerId), System.currentTimeMillis());
        notification.defaults = Notification.DEFAULT_LIGHTS;
        notification.flags = Notification.FLAG_AUTO_CANCEL;
        PendingIntent pendingIntent;
        if (tickerId != R.string.ticker_success) {
            // 同步失败时，点击通知跳转到设置页面
            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
-                    NotesPreferenceActivity.class), PendingIntent.FLAG_IMMUTABLE);
+                    NotesPreferenceActivity.class), 0);
        } else {
            // 同步成功时，点击通知跳转到笔记列表页面
            pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
-                    NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE);
+                    NotesListActivity.class), 0);
        }
-        // 创建通知构建器
+        notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
-        Notification.Builder builder = new Notification.Builder(mContext)
+                pendingIntent);
-                .setAutoCancel(true) // 点击后自动取消通知
+        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
                .setContentTitle(mContext.getString(R.string.app_name)) // 设置通知标题
                .setContentText(content) // 设置通知内容
                .setContentIntent(pendingIntent) // 设置点击通知时的跳转意图
                .setWhen(System.currentTimeMillis()) // 设置通知时间
                .setOngoing(true); // 设置为持续通知
        Notification notification=builder.getNotification();
        mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); // 显示通知
    }
    @Override
    protected Integer doInBackground(Void... unused) {
        publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
@ -61,44 +61,35 @@ import java.util.zip.Inflater;
 import java.util.zip.InflaterInputStream;
 /**
 * Google Tasks客户端
 * 实现与Google Tasks API的通信，处理任务和任务列表的CRUD操作
 * 使用单例模式确保全局只有一个实例
 */
 public class GTaskClient {
-    private static final String TAG = GTaskClient.class.getSimpleName();  // 日志标签
+    private static final String TAG = GTaskClient.class.getSimpleName();
-    private static final String GTASK_URL = "https://mail.google.com/tasks/";  // Google Tasks基础URL
+    private static final String GTASK_URL = "https://mail.google.com/tasks/";
-    private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";  // Google Tasks GET请求URL
+    private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
-    private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";  // Google Tasks POST请求URL
+    private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
-    private static GTaskClient mInstance = null;  // 单例实例
+    private static GTaskClient mInstance = null;
-    private DefaultHttpClient mHttpClient;  // HTTP客户端实例
+    private DefaultHttpClient mHttpClient;
-    private String mGetUrl;  // 当前使用的GET请求URL
+    private String mGetUrl;
-    private String mPostUrl;  // 当前使用的POST请求URL
+    private String mPostUrl;
-    private long mClientVersion;  // 客户端版本号
+    private long mClientVersion;
-    private boolean mLoggedin;  // 登录状态标识
+    private boolean mLoggedin;
-    private long mLastLoginTime;  // 最后登录时间
+    private long mLastLoginTime;
-    private int mActionId;  // 操作ID计数器
+    private int mActionId;
-    private Account mAccount;  // Google账户
+    private Account mAccount;
-    private JSONArray mUpdateArray;  // 更新操作数组，用于批量提交更新
+    private JSONArray mUpdateArray;
    /**
     * 私有构造函数 - 初始化客户端实例
     * 单例模式确保外部无法直接创建实例
     */
    private GTaskClient() {
        mHttpClient = null;
        mGetUrl = GTASK_GET_URL;
@ -111,11 +102,6 @@ public class GTaskClient {
        mUpdateArray = null;
    }
    /**
     * 获取GTaskClient的单例实例
     * 使用同步方法确保线程安全
     * @return GTaskClient单例实例
     */
    public static synchronized GTaskClient getInstance() {
        if (mInstance == null) {
            mInstance = new GTaskClient();
@ -123,13 +109,6 @@ public class GTaskClient {
        return mInstance;
    }
    /**
     * 登录Google Tasks服务
     * 如果已经登录且会话未过期，则直接返回true
     * 否则重新登录Google账户并建立与Google Tasks的连接
     * @param activity 调用该方法的Activity实例，用于获取账户信息
     * @return 是否登录成功
     */
    public boolean login(Activity activity) {
        // we suppose that the cookie would expire after 5 minutes
        // then we need to re-login
@ -185,12 +164,6 @@ public class GTaskClient {
        return true;
    }
    /**
     * 登录Google账户并获取认证令牌
     * @param activity 调用该方法的Activity实例，用于获取账户信息
     * @param invalidateToken 是否使当前令牌无效并重新获取
     * @return 认证令牌，如果获取失败则返回null
     */
    private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
        String authToken;
        AccountManager accountManager = AccountManager.get(activity);
@ -234,13 +207,6 @@ public class GTaskClient {
        return authToken;
    }
    /**
     * 尝试使用认证令牌登录Google Tasks服务
     * 如果第一次登录失败，会尝试重新获取令牌并再次登录
     * @param activity 调用该方法的Activity实例，用于重新获取令牌
     * @param authToken 认证令牌
     * @return 是否登录成功
     */
    private boolean tryToLoginGtask(Activity activity, String authToken) {
        if (!loginGtask(authToken)) {
            // maybe the auth token is out of date, now let's invalidate the
@ -259,12 +225,6 @@ public class GTaskClient {
        return true;
    }
    /**
     * 使用认证令牌登录Google Tasks服务
     * 配置HTTP客户端，设置超时时间，发送登录请求并处理响应
     * @param authToken 认证令牌
     * @return 是否登录成功
     */
    private boolean loginGtask(String authToken) {
        int timeoutConnection = 10000;
        int timeoutSocket = 15000;
@ -320,20 +280,10 @@ public class GTaskClient {
        return true;
    }
    /**
     * 获取唯一的操作ID
     * 每次调用都会递增操作ID计数器
     * @return 新的操作ID
     */
    private int getActionId() {
        return mActionId++;
    }
    /**
     * 创建HTTP POST请求对象
     * 设置请求URL和必要的请求头
     * @return 配置好的HttpPost对象
     */
    private HttpPost createHttpPost() {
        HttpPost httpPost = new HttpPost(mPostUrl);
        httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
@ -341,13 +291,6 @@ public class GTaskClient {
        return httpPost;
    }
    /**
     * 获取HTTP响应内容
     * 支持gzip和deflate压缩格式，自动解压并返回字符串内容
     * @param entity HTTP响应实体
     * @return 响应内容字符串
     * @throws IOException 如果读取响应内容失败
     */
    private String getResponseContent(HttpEntity entity) throws IOException {
        String contentEncoding = null;
        if (entity.getContentEncoding() != null) {
@ -380,14 +323,6 @@ public class GTaskClient {
        }
    }
    /**
     * 发送POST请求到Google Tasks API
     * 封装JSON数据并发送请求，处理响应并返回JSON对象
     * @param js 要发送的JSON对象
     * @return 响应的JSON对象
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果请求处理失败
     */
    private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
        if (!mLoggedin) {
            Log.e(TAG, "please login first");
@ -425,13 +360,6 @@ public class GTaskClient {
        }
    }
    /**
     * 创建新的Google Tasks任务
     * 提交更新并发送创建任务的请求，处理响应并更新任务的GID
     * @param task 要创建的任务对象
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果创建任务失败
     */
    public void createTask(Task task) throws NetworkFailureException {
        commitUpdate();
        try {
@ -458,13 +386,6 @@ public class GTaskClient {
        }
    }
    /**
     * 创建新的Google Tasks任务列表
     * 提交更新并发送创建任务列表的请求，处理响应并更新任务列表的GID
     * @param tasklist 要创建的任务列表对象
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果创建任务列表失败
     */
    public void createTaskList(TaskList tasklist) throws NetworkFailureException {
        commitUpdate();
        try {
@ -491,12 +412,6 @@ public class GTaskClient {
        }
    }
    /**
     * 提交更新到Google Tasks服务器
     * 将mUpdateArray中的所有更新操作批量发送到服务器
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果更新处理失败
     */
    public void commitUpdate() throws NetworkFailureException {
        if (mUpdateArray != null) {
            try {
@ -518,12 +433,6 @@ public class GTaskClient {
        }
    }
    /**
     * 将节点添加到更新数组中
     * 当更新数组超过10个元素时，会自动提交更新
     * @param node 要添加的节点对象
     * @throws NetworkFailureException 如果提交更新时网络请求失败
     */
    public void addUpdateNode(Node node) throws NetworkFailureException {
        if (node != null) {
            // too many update items may result in an error
@ -538,15 +447,6 @@ public class GTaskClient {
        }
    }
    /**
     * 移动任务位置
     * 可以在同一个任务列表内移动任务，也可以将任务从一个任务列表移动到另一个任务列表
     * @param task 要移动的任务对象
     * @param preParent 移动前的父任务列表
     * @param curParent 移动后的父任务列表
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果移动任务失败
     */
    public void moveTask(Task task, TaskList preParent, TaskList curParent)
            throws NetworkFailureException {
        commitUpdate();
@ -586,13 +486,6 @@ public class GTaskClient {
        }
    }
    /**
     * 删除节点
     * 将节点标记为已删除并发送删除请求到Google Tasks服务器
     * @param node 要删除的节点对象
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果删除节点失败
     */
    public void deleteNode(Node node) throws NetworkFailureException {
        commitUpdate();
        try {
@ -616,13 +509,6 @@ public class GTaskClient {
        }
    }
    /**
     * 获取所有任务列表
     * 从Google Tasks服务器获取所有任务列表信息
     * @return 任务列表的JSON数组
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果获取任务列表失败
     */
    public JSONArray getTaskLists() throws NetworkFailureException {
        if (!mLoggedin) {
            Log.e(TAG, "please login first");
@ -661,14 +547,6 @@ public class GTaskClient {
        }
    }
    /**
     * 获取指定任务列表中的所有任务
     * 从Google Tasks服务器获取指定任务列表的所有任务信息
     * @param listGid 任务列表的GID
     * @return 任务的JSON数组
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果获取任务失败
     */
    public JSONArray getTaskList(String listGid) throws NetworkFailureException {
        commitUpdate();
        try {
@ -697,18 +575,10 @@ public class GTaskClient {
        }
    }
    /**
     * 获取当前同步的Google账户
     * @return 当前同步的Account对象
     */
    public Account getSyncAccount() {
        return mAccount;
    }
    /**
     * 重置更新数组
     * 清空mUpdateArray中的所有更新操作
     */
    public void resetUpdateArray() {
        mUpdateArray = null;
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
@ -48,45 +48,45 @@ import java.util.Iterator;
 import java.util.Map;
 /**
 * Google Tasks同步管理器
 * 负责处理本地笔记与Google Tasks之间的同步逻辑
 * 实现单例模式，管理同步状态和同步操作
 */
 public class GTaskManager {
-    private static final String TAG = GTaskManager.class.getSimpleName();  // 日志标签
+    private static final String TAG = GTaskManager.class.getSimpleName();
-
+
-    // 同步状态常量定义
+    public static final int STATE_SUCCESS = 0;
-    public static final int STATE_SUCCESS = 0;              // 同步成功
+
-    public static final int STATE_NETWORK_ERROR = 1;        // 网络错误
+    public static final int STATE_NETWORK_ERROR = 1;
-    public static final int STATE_INTERNAL_ERROR = 2;       // 内部错误
+
-    public static final int STATE_SYNC_IN_PROGRESS = 3;     // 同步进行中
+    public static final int STATE_INTERNAL_ERROR = 2;
-    public static final int STATE_SYNC_CANCELLED = 4;       // 同步已取消
+
-
+    public static final int STATE_SYNC_IN_PROGRESS = 3;
-    private static GTaskManager mInstance = null;           // 单例实例
+
-
+    public static final int STATE_SYNC_CANCELLED = 4;
-    private Activity mActivity;                             // 用于获取认证令牌的Activity实例
+
-    private Context mContext;                               // 应用上下文
+    private static GTaskManager mInstance = null;
-    private ContentResolver mContentResolver;               // 内容解析器，用于访问本地数据库
+
-
+    private Activity mActivity;
-    private boolean mSyncing;                               // 同步状态标志
+
-    private boolean mCancelled;                             // 同步取消标志
+    private Context mContext;
-
+
-    // Google Tasks数据结构映射
+    private ContentResolver mContentResolver;
-    private HashMap<String, TaskList> mGTaskListHashMap;    // Google任务列表映射
+
-    private HashMap<String, Node> mGTaskHashMap;            // Google任务节点映射
+    private boolean mSyncing;
-    private HashMap<String, MetaData> mMetaHashMap;         // 元数据映射
+
-    private TaskList mMetaList;                             // 元数据任务列表
+    private boolean mCancelled;
-
+
-    // 同步辅助数据结构
+    private HashMap<String, TaskList> mGTaskListHashMap;
-    private HashSet<Long> mLocalDeleteIdMap;                // 本地删除的笔记ID集合
+
-    private HashMap<String, Long> mGidToNid;                // Google任务ID到本地笔记ID的映射
+    private HashMap<String, Node> mGTaskHashMap;
-    private HashMap<Long, String> mNidToGid;                // 本地笔记ID到Google任务ID的映射
+
-
+    private HashMap<String, MetaData> mMetaHashMap;
-    /**
+
-     * 私有构造函数 - 初始化同步管理器实例
+    private TaskList mMetaList;
-     * 初始化所有同步相关的数据结构和状态标志
+
-     */
+    private HashSet<Long> mLocalDeleteIdMap;
    private HashMap<String, Long> mGidToNid;
    private HashMap<Long, String> mNidToGid;
    private GTaskManager() {
        mSyncing = false;
        mCancelled = false;
@ -99,11 +99,6 @@ public class GTaskManager {
        mNidToGid = new HashMap<Long, String>();
    }
    /**
     * 获取GTaskManager的单例实例
     * 使用同步方法确保线程安全
     * @return GTaskManager单例实例
     */
    public static synchronized GTaskManager getInstance() {
        if (mInstance == null) {
            mInstance = new GTaskManager();
@ -111,28 +106,11 @@ public class GTaskManager {
        return mInstance;
    }
    /**
     * 设置Activity上下文
     * 用于后续获取Google认证令牌
     * @param activity 用于获取认证令牌的Activity实例
     */
    public synchronized void setActivityContext(Activity activity) {
        // used for getting authtoken
        mActivity = activity;
    }
    /**
     * 执行笔记与Google Tasks之间的同步操作
     * 这是GTaskManager的核心方法，协调整个同步流程
     * @param context 应用上下文
     * @param asyncTask 异步任务实例，用于发布同步进度
     * @return 同步状态码：
     *         STATE_SUCCESS - 同步成功
     *         STATE_NETWORK_ERROR - 网络错误
     *         STATE_INTERNAL_ERROR - 内部错误
     *         STATE_SYNC_IN_PROGRESS - 同步进行中
     *         STATE_SYNC_CANCELLED - 同步已取消
     */
    public int sync(Context context, GTaskASyncTask asyncTask) {
        if (mSyncing) {
            Log.d(TAG, "Sync is in progress");
@ -190,13 +168,6 @@ public class GTaskManager {
        return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
    }
    /**
     * 初始化Google Tasks列表
     * 从Google服务器获取所有任务列表和任务数据，并构建本地映射
     * 处理元数据任务列表，确保其存在
     * @throws NetworkFailureException 如果网络请求失败
     * @throws ActionFailureException 如果处理JSON数据失败
     */
    private void initGTaskList() throws NetworkFailureException {
        if (mCancelled)
            return;
@ -276,18 +247,6 @@ public class GTaskManager {
        }
    }
    /**
     * 同步内容
     * 处理本地和Google Tasks之间的内容同步
     * 包括：
     * 1. 处理本地已删除的笔记
     * 2. 同步文件夹
     * 3. 处理本地已存在的笔记
     * 4. 处理Google端新增的内容
     * 5. 清理本地删除的笔记
     * 6. 刷新本地同步ID
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void syncContent() throws NetworkFailureException {
        int syncType;
        Cursor c = null;
@ -392,16 +351,6 @@ public class GTaskManager {
    }
    /**
     * 同步文件夹
     * 处理本地和Google Tasks之间的文件夹同步
     * 包括：
     * 1. 同步根文件夹
     * 2. 同步通话记录文件夹
     * 3. 同步本地已存在的普通文件夹
     * 4. 同步Google端新增的文件夹
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void syncFolder() throws NetworkFailureException {
        Cursor c = null;
        String gid;
@ -527,21 +476,6 @@ public class GTaskManager {
            GTaskClient.getInstance().commitUpdate();
    }
    /**
     * 执行内容同步操作
     * 根据同步类型执行不同的同步动作
     * @param syncType 同步类型：
     *                 Node.SYNC_ACTION_ADD_LOCAL - 本地添加
     *                 Node.SYNC_ACTION_ADD_REMOTE - 远程添加
     *                 Node.SYNC_ACTION_DEL_LOCAL - 本地删除
     *                 Node.SYNC_ACTION_DEL_REMOTE - 远程删除
     *                 Node.SYNC_ACTION_UPDATE_LOCAL - 本地更新
     *                 Node.SYNC_ACTION_UPDATE_REMOTE - 远程更新
     *                 Node.SYNC_ACTION_UPDATE_CONFLICT - 更新冲突
     * @param node 要同步的节点
     * @param c 本地数据库游标
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
        if (mCancelled) {
            return;
@ -588,12 +522,6 @@ public class GTaskManager {
        }
    }
    /**
     * 添加本地节点
     * 将Google Tasks中的节点添加到本地数据库
     * @param node 要添加的Google Tasks节点
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void addLocalNode(Node node) throws NetworkFailureException {
        if (mCancelled) {
            return;
@ -668,13 +596,6 @@ public class GTaskManager {
        updateRemoteMeta(node.getGid(), sqlNote);
    }
    /**
     * 更新本地节点
     * 使用Google Tasks中的节点信息更新本地数据库中的笔记
     * @param node Google Tasks中的节点信息
     * @param c 本地数据库游标
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
        if (mCancelled) {
            return;
@ -698,13 +619,6 @@ public class GTaskManager {
        updateRemoteMeta(node.getGid(), sqlNote);
    }
    /**
     * 添加远程节点
     * 将本地数据库中的笔记添加到Google Tasks
     * @param node Google Tasks节点（可能为null）
     * @param c 本地数据库游标
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
        if (mCancelled) {
            return;
@ -778,14 +692,6 @@ public class GTaskManager {
        mNidToGid.put(sqlNote.getId(), n.getGid());
    }
    /**
     * 更新远程节点
     * 将本地数据库中笔记的更新同步到Google Tasks
     * 如果需要，还会处理任务的移动（更改父文件夹）
     * @param node Google Tasks节点
     * @param c 本地数据库游标
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
        if (mCancelled) {
            return;
@ -824,13 +730,6 @@ public class GTaskManager {
        sqlNote.commit(true);
    }
    /**
     * 更新远程元数据
     * 将本地笔记的元数据信息更新到Google Tasks的元数据列表中
     * @param gid Google Tasks节点ID
     * @param sqlNote 本地笔记对象
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
        if (sqlNote != null && sqlNote.isNoteType()) {
            MetaData metaData = mMetaHashMap.get(gid);
@ -847,12 +746,6 @@ public class GTaskManager {
        }
    }
    /**
     * 刷新本地同步ID
     * 同步完成后，更新本地笔记的同步ID为Google Tasks的最后修改时间
     * 确保下次同步时能正确检测到更改
     * @throws NetworkFailureException 如果网络请求失败
     */
    private void refreshLocalSyncId() throws NetworkFailureException {
        if (mCancelled) {
            return;
@ -897,18 +790,10 @@ public class GTaskManager {
        }
    }
    /**
     * 获取当前同步账户
     * @return 当前用于Google Tasks同步的账户名称
     */
    public String getSyncAccount() {
        return GTaskClient.getInstance().getSyncAccount().name;
    }
    /**
     * 取消当前同步操作
     * 设置取消标志，使正在进行的同步操作能够优雅地终止
     */
    public void cancelSync() {
        mCancelled = true;
    }
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
@ -23,33 +23,25 @@ import android.content.Intent;
 import android.os.Bundle;
 import android.os.IBinder;
 /**
 * Google Tasks同步服务
 * 管理Google Tasks与本地笔记之间的同步操作的Service组件
 * 提供开始同步、取消同步的功能，并通过广播通知同步状态和进度
 */
 public class GTaskSyncService extends Service {
-    // 动作类型常量定义
+    public final static String ACTION_STRING_NAME = "sync_action_type";
-    public final static String ACTION_STRING_NAME = "sync_action_type";  // 动作类型的Intent额外数据键
+
-
+    public final static int ACTION_START_SYNC = 0;
-    public final static int ACTION_START_SYNC = 0;                       // 开始同步动作
+
-    public final static int ACTION_CANCEL_SYNC = 1;                      // 取消同步动作
+    public final static int ACTION_CANCEL_SYNC = 1;
-    public final static int ACTION_INVALID = 2;                          // 无效动作
+
-
+    public final static int ACTION_INVALID = 2;
-    // 广播相关常量定义
+
-    public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";  // 广播的Intent动作名称
+    public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
-    public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";                                    // 广播中同步状态的键
+
-    public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";                                // 广播中同步进度消息的键
+    public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
-
+
-    // 同步任务相关变量
+    public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
-    private static GTaskASyncTask mSyncTask = null;     // 当前执行的同步任务实例
+
-    private static String mSyncProgress = "";           // 当前同步进度消息
+    private static GTaskASyncTask mSyncTask = null;
-
+
-    /**
+    private static String mSyncProgress = "";
-     * 启动同步操作
+
     * 创建并执行Google Tasks同步异步任务
     * 如果已经有同步任务在执行，则不重复启动
     */
    private void startSync() {
        if (mSyncTask == null) {
            mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@ -64,10 +56,6 @@ public class GTaskSyncService extends Service {
        }
    }
    /**
     * 取消同步操作
     * 如果有同步任务正在执行，则取消该任务
     */
    private void cancelSync() {
        if (mSyncTask != null) {
            mSyncTask.cancelSync();
@ -76,13 +64,11 @@ public class GTaskSyncService extends Service {
    @Override
    public void onCreate() {
        // 服务创建时初始化同步任务为null
        mSyncTask = null;
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 处理传入的Intent，根据动作类型执行相应的同步操作
        Bundle bundle = intent.getExtras();
        if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
            switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
@ -95,7 +81,6 @@ public class GTaskSyncService extends Service {
                default:
                    break;
            }
            // 返回START_STICKY表示如果服务被系统杀死，会在资源允许时重新创建
            return START_STICKY;
        }
        return super.onStartCommand(intent, flags, startId);
@ -103,28 +88,15 @@ public class GTaskSyncService extends Service {
    @Override
    public void onLowMemory() {
        // 系统内存不足时，如果有同步任务正在执行，则取消它以释放资源
        if (mSyncTask != null) {
            mSyncTask.cancelSync();
        }
    }
    /**
     * Service的绑定方法
     * 该服务不支持绑定，因此返回null
     * @param intent 绑定意图
     * @return null
     */
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    /**
     * 发送同步状态广播
     * 通知应用其他组件同步的当前状态和进度
     * @param msg 同步进度消息
     */
    public void sendBroadcast(String msg) {
        mSyncProgress = msg;
        Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@ -133,11 +105,6 @@ public class GTaskSyncService extends Service {
        sendBroadcast(intent);
    }
    /**
     * 静态方法：启动Google Tasks同步服务
     * 这是启动同步的公共入口方法，设置Activity上下文并发送启动同步的Intent
     * @param activity 用于获取Google认证的Activity实例
     */
    public static void startSync(Activity activity) {
        GTaskManager.getInstance().setActivityContext(activity);
        Intent intent = new Intent(activity, GTaskSyncService.class);
@ -145,29 +112,16 @@ public class GTaskSyncService extends Service {
        activity.startService(intent);
    }
    /**
     * 静态方法：取消Google Tasks同步服务
     * 这是取消同步的公共入口方法，发送取消同步的Intent
     * @param context 应用上下文
     */
    public static void cancelSync(Context context) {
        Intent intent = new Intent(context, GTaskSyncService.class);
        intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
        context.startService(intent);
    }
    /**
     * 静态方法：检查是否正在同步
     * @return true表示正在同步，false表示未在同步
     */
    public static boolean isSyncing() {
        return mSyncTask != null;
    }
    /**
     * 静态方法：获取当前同步进度消息
     * @return 当前同步进度消息字符串
     */
    public static String getProgressString() {
        return mSyncProgress;
    }
--- a/src/Notes-master/src/net/micode/notes/model/Note.java
+++ b/src/Notes-master/src/net/micode/notes/model/Note.java
@ -34,26 +34,15 @@ 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";
    /**
-     * 创建新笔记并返回ID。
+     * Create a new note id for adding a new note to databases
     *
     * @param context 上下文对象
     * @param folderId 目标父文件夹ID
     * @return 新创建的笔记ID（>0）；失败抛出异常或返回0
     */
    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);
@ -76,82 +65,41 @@ 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());
    }
    /**
     * 设置文本数据字段（data 表）。
     * @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);
    }
    /**
     * 设置通话数据字段（data 表）。
     * @param key 字段名
     * @param value 字段值
     */
    public void setCallData(String key, String value) {
        mNoteData.setCallData(key, value);
    }
    /**
     * 检查笔记是否在本地被修改
     * @return 如果笔记在本地被修改，返回true，否则返回false
     */
    public boolean isLocalModified() {
        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
    }
    /**
     * 将笔记的增量更新同步到数据库。
     *
     * @param context 上下文对象
     * @param noteId 笔记ID
     * @return 同步成功返回 true，失败返回 false
     */
    public boolean syncNote(Context context, long noteId) {
        if (noteId <= 0) {
            throw new IllegalArgumentException("Wrong note id:" + noteId);
@ -161,12 +109,16 @@ public class Note {
            return true;
        }
-        // 理论上任何变更都应更新 LOCAL_MODIFIED 与 MODIFIED_DATE；即便 note 表更新失败，也继续尝试写 data
+        /**
         * 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();
@ -178,22 +130,17 @@ public class Note {
        return true;
    }
    /**
     * 笔记数据内部类
     * 用于管理笔记的具体内容数据，支持文本笔记和通话笔记
     */
    private class NoteData {
-        private long mTextDataId;      // 文本笔记数据ID
+        private long mTextDataId;
        private ContentValues mTextDataValues;  // 文本笔记数据值
        private long mCallDataId;      // 通话笔记数据ID
        private ContentValues mCallDataValues;  // 通话笔记数据值
        private static final String TAG = "NoteData";  // 日志标签
        private ContentValues mTextDataValues;
        private long mCallDataId;
        private ContentValues mCallDataValues;
        private static final String TAG = "NoteData";
        /** 构造函数：初始化两个数据集与对应 ID */
        public NoteData() {
            mTextDataValues = new ContentValues();
            mCallDataValues = new ContentValues();
@ -201,19 +148,10 @@ 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");
@ -221,11 +159,6 @@ 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");
@ -233,37 +166,22 @@ public class Note {
            mCallDataId = id;
        }
        /**
         * 设置通话数据字段，并同步标记 note 为本地修改。
         * @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());
        }
        /**
         * 设置文本数据字段，并同步标记 note 为本地修改。
         * @param key 字段名
         * @param value 字段值
         */
        void setTextData(String key, String value) {
            mTextDataValues.put(key, value);
            mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
            mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
        }
        /**
         * 将笔记数据推入内容解析器
         * 将本地修改的笔记数据同步到数据库中
         * @param context 上下文对象
         * @param noteId 笔记ID
         * @return 同步后的URI，同步失败返回null
         */
        Uri pushIntoContentResolver(Context context, long noteId) {
-            // 安全检查
+            /**
             * Check for safety
             */
            if (noteId <= 0) {
                throw new IllegalArgumentException("Wrong note id:" + noteId);
            }
@ -272,7 +190,6 @@ public class Note {
            ContentProviderOperation.Builder builder = null;
            if(mTextDataValues.size() > 0) {
                // 写入或更新文本数据（MIME: text_note）
                mTextDataValues.put(DataColumns.NOTE_ID, noteId);
                if (mTextDataId == 0) {
                    mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
@ -295,7 +212,6 @@ public class Note {
            }
            if(mCallDataValues.size() > 0) {
                // 写入或更新通话数据（MIME: call_note）
                mCallDataValues.put(DataColumns.NOTE_ID, noteId);
                if (mCallDataId == 0) {
                    mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
--- a/src/Notes-master/src/net/micode/notes/model/WorkingNote.java
+++ b/src/Notes-master/src/net/micode/notes/model/WorkingNote.java
@ -31,79 +31,77 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.Notes.TextNote;
 import net.micode.notes.tool.ResourceParser.NoteBgResources;
-/**
+
 * 工作笔记类。
 * <p>职责：代表当前正在编辑/展示的笔记，封装从数据库加载、修改、保存、以及小部件联动等操作。</p>
 * <p>使用场景：编辑页、列表点击进入编辑、或小部件创建笔记时，都通过该类聚合业务逻辑。</p>
 */
 /**
 * 工作笔记
 * 用于在用户界面层管理笔记的编辑状态和操作
 * 封装了笔记的数据模型和用户交互相关的逻辑
 */
 public class WorkingNote {
-    private Note mNote;                          // 实际的笔记数据模型
+    // Note for the working note
-    private long mNoteId;                        // 笔记ID
+    private Note mNote;
-    private String mContent;                     // 笔记内容
+    // Note Id
-    private int mMode;                           // 笔记模式（普通模式/清单模式）
+    private long mNoteId;
-    private long mAlertDate;                     // 提醒日期时间
+    // Note content
-    private long mModifiedDate;                  // 最后修改时间
+    private String mContent;
-    private int mBgColorId;                      // 背景颜色ID
+    // Note mode
-    private int mWidgetId;                       // 小部件ID
+    private int mMode;
-    private int mWidgetType;                     // 小部件类型
+
-    private long mFolderId;                      // 所属文件夹ID
+    private long mAlertDate;
-    private Context mContext;                    // 上下文对象
+
-    private static final String TAG = "WorkingNote";  // 日志标签
+    private long mModifiedDate;
-    private boolean mIsDeleted;                  // 是否已删除
+
-    private NoteSettingChangedListener mNoteSettingStatusListener;  // 笔记设置变化监听器
+    private int mBgColorId;
    private int mWidgetId;
    private int mWidgetType;
    private long mFolderId;
    private Context mContext;
    private static final String TAG = "WorkingNote";
    private boolean mIsDeleted;
    private NoteSettingChangedListener mNoteSettingStatusListener;
    public static final String[] DATA_PROJECTION = new String[] {
-            DataColumns.ID,           // 数据ID
+            DataColumns.ID,
-            DataColumns.CONTENT,      // 笔记内容
+            DataColumns.CONTENT,
-            DataColumns.MIME_TYPE,    // 数据类型
+            DataColumns.MIME_TYPE,
-            DataColumns.DATA1,        // 附加数据1
+            DataColumns.DATA1,
-            DataColumns.DATA2,        // 附加数据2
+            DataColumns.DATA2,
-            DataColumns.DATA3,        // 附加数据3
+            DataColumns.DATA3,
-            DataColumns.DATA4,        // 附加数据4
+            DataColumns.DATA4,
    };
    /**
     * 笔记元数据查询投影列
     * 用于查询笔记的基本信息
     */
    public static final String[] NOTE_PROJECTION = new String[] {
-            NoteColumns.PARENT_ID,     // 所属文件夹ID
+            NoteColumns.PARENT_ID,
-            NoteColumns.ALERTED_DATE,  // 提醒日期
+            NoteColumns.ALERTED_DATE,
-            NoteColumns.BG_COLOR_ID,   // 背景颜色ID
+            NoteColumns.BG_COLOR_ID,
-            NoteColumns.WIDGET_ID,     // 小部件ID
+            NoteColumns.WIDGET_ID,
-            NoteColumns.WIDGET_TYPE,   // 小部件类型
+            NoteColumns.WIDGET_TYPE,
-            NoteColumns.MODIFIED_DATE  // 修改日期
+            NoteColumns.MODIFIED_DATE
    };
-    // 数据查询结果列索引
+    private static final int DATA_ID_COLUMN = 0;
-    private static final int DATA_ID_COLUMN = 0;                // 数据ID列索引
+
-    private static final int DATA_CONTENT_COLUMN = 1;           // 内容列索引
+    private static final int DATA_CONTENT_COLUMN = 1;
-    private static final int DATA_MIME_TYPE_COLUMN = 2;         // MIME类型列索引
+
-    private static final int DATA_MODE_COLUMN = 3;              // 模式列索引
+    private static final int DATA_MIME_TYPE_COLUMN = 2;
    private static final int DATA_MODE_COLUMN = 3;
    private static final int NOTE_PARENT_ID_COLUMN = 0;
    private static final int NOTE_ALERTED_DATE_COLUMN = 1;
    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
-    // 笔记查询结果列索引
+    private static final int NOTE_WIDGET_ID_COLUMN = 3;
    private static final int NOTE_PARENT_ID_COLUMN = 0;         // 父文件夹ID列索引
    private static final int NOTE_ALERTED_DATE_COLUMN = 1;      // 提醒日期列索引
    private static final int NOTE_BG_COLOR_ID_COLUMN = 2;       // 背景颜色ID列索引
    private static final int NOTE_WIDGET_ID_COLUMN = 3;         // 小部件ID列索引
    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;       // 小部件类型列索引
    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;     // 修改日期列索引
    private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
    private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
-    /**
+    // New note construct
     * 新建笔记的构造函数。
     *
     * @param context 上下文对象
     * @param folderId 文件夹ID
     */
    private WorkingNote(Context context, long folderId) {
        mContext = context;
        mAlertDate = 0;
@ -116,12 +114,7 @@ public class WorkingNote {
        mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
    }
-    /**
+    // Existing note construct
     * 构造方法 - 加载现有笔记
     * @param context 上下文对象
     * @param noteId 笔记ID
     * @param folderId 所属文件夹ID
     */
    private WorkingNote(Context context, long noteId, long folderId) {
        mContext = context;
        mNoteId = noteId;
@ -131,10 +124,6 @@ public class WorkingNote {
        loadNote();
    }
    /**
     * 加载笔记元数据（note 表），包括父文件夹、背景色、小部件、提醒、修改时间等。
     * 加载完成后再拉取 data 表详细内容。
     */
    private void loadNote() {
        Cursor cursor = mContext.getContentResolver().query(
                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
@ -157,10 +146,6 @@ public class WorkingNote {
        loadNoteData();
    }
    /**
     * 加载笔记的数据内容（data 表）。
     * <p>遍历该笔记的所有数据行：找到文本行（NOTE）记录内容与模式；找到通话行（CALL_NOTE）记录其数据ID。</p>
     */
    private void loadNoteData() {
        Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
                DataColumns.NOTE_ID + "=?", new String[] {
@ -189,16 +174,6 @@ public class WorkingNote {
        }
    }
    /**
     * 创建空白笔记实例（尚未写入数据库）。
     *
     * @param context 上下文对象
     * @param folderId 目标文件夹ID
     * @param widgetId 关联小部件ID
     * @param widgetType 小部件类型
     * @param defaultBgColorId 默认背景色
     * @return 工作笔记对象
     */
    public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
            int widgetType, int defaultBgColorId) {
        WorkingNote note = new WorkingNote(context, folderId);
@ -208,21 +183,10 @@ public class WorkingNote {
        return note;
    }
    /**
     * 从数据库加载指定ID的笔记
     * @param context 上下文对象
     * @param id 笔记ID
     * @return 加载的工作笔记对象
     */
    public static WorkingNote load(Context context, long id) {
        return new WorkingNote(context, id, 0);
    }
    /**
     * 保存笔记：必要时创建新记录，然后同步增量到 note/data，并刷新小部件。
     *
     * @return 保存成功返回true，否则返回false
     */
    public synchronized boolean saveNote() {
        if (isWorthSaving()) {
            if (!existInDatabase()) {
@ -234,7 +198,9 @@ public class WorkingNote {
            mNote.syncNote(mContext, mNoteId);
-            // 如果该笔记存在小部件，更新小部件内容
+            /**
             * Update widget content if there exist any widget of this note
             */
            if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
                    && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
                    && mNoteSettingStatusListener != null) {
@ -246,19 +212,10 @@ public class WorkingNote {
        }
    }
    /**
     * 判断笔记是否已有持久化记录（noteId>0）。
     * @return 存在返回true
     */
    public boolean existInDatabase() {
        return mNoteId > 0;
    }
    /**
     * 检查笔记是否值得保存
     * 当笔记已删除、空内容且不存在于数据库中、或存在于数据库但未被修改时，不值得保存
     * @return 如果笔记值得保存返回true，否则返回false
     */
    private boolean isWorthSaving() {
        if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
                || (existInDatabase() && !mNote.isLocalModified())) {
@ -268,19 +225,10 @@ public class WorkingNote {
        }
    }
    /**
     * 注册笔记设置变化监听器（用于通知 UI 或小部件刷新）。
     * @param l 监听器对象
     */
    public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
        mNoteSettingStatusListener = l;
    }
    /**
     * 设置提醒时间，并通知监听器。
     * @param date 提醒日期时间戳
     * @param set 是否设置提醒
     */
    public void setAlertDate(long date, boolean set) {
        if (date != mAlertDate) {
            mAlertDate = date;
@ -291,10 +239,6 @@ public class WorkingNote {
        }
    }
    /**
     * 标记笔记为已删除，若关联小部件则触发刷新。
     * @param mark 是否标记为删除
     */
    public void markDeleted(boolean mark) {
        mIsDeleted = mark;
        if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@ -303,10 +247,6 @@ public class WorkingNote {
        }
    }
    /**
     * 设置背景颜色，并通知监听器、记录本地修改。
     * @param id 背景颜色ID
     */
    public void setBgColorId(int id) {
        if (id != mBgColorId) {
            mBgColorId = id;
@ -317,10 +257,6 @@ public class WorkingNote {
        }
    }
    /**
     * 设置清单模式。
     * @param mode 模式（0 普通，1 清单）
     */
    public void setCheckListMode(int mode) {
        if (mMode != mode) {
            if (mNoteSettingStatusListener != null) {
@ -331,10 +267,6 @@ public class WorkingNote {
        }
    }
    /**
     * 设置笔记小部件类型
     * @param type 小部件类型
     */
    public void setWidgetType(int type) {
        if (type != mWidgetType) {
            mWidgetType = type;
@ -342,10 +274,6 @@ public class WorkingNote {
        }
    }
    /**
     * 设置笔记小部件ID
     * @param id 小部件ID
     */
    public void setWidgetId(int id) {
        if (id != mWidgetId) {
            mWidgetId = id;
@ -353,10 +281,6 @@ public class WorkingNote {
        }
    }
    /**
     * 设置笔记工作内容
     * @param text 笔记内容
     */
    public void setWorkingText(String text) {
        if (!TextUtils.equals(mContent, text)) {
            mContent = text;
@ -364,139 +288,80 @@ public class WorkingNote {
        }
    }
    /**
     * 将笔记转换为通话记录笔记
     * @param phoneNumber 电话号码
     * @param callDate 通话日期时间
     */
    public void convertToCallNote(String phoneNumber, long callDate) {
        mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
        mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
        mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
    }
    /**
     * 检查笔记是否设置了提醒
     * @return 如果设置了提醒返回true，否则返回false
     */
    public boolean hasClockAlert() {
        return (mAlertDate > 0 ? true : false);
    }
    /**
     * 获取笔记内容
     * @return 笔记内容
     */
    public String getContent() {
        return mContent;
    }
    /**
     * 获取笔记提醒日期
     * @return 提醒日期时间
     */
    public long getAlertDate() {
        return mAlertDate;
    }
    /**
     * 获取笔记最后修改时间
     * @return 最后修改时间
     */
    public long getModifiedDate() {
        return mModifiedDate;
    }
    /**
     * 获取笔记背景颜色资源ID
     * @return 背景颜色资源ID
     */
    public int getBgColorResId() {
        return NoteBgResources.getNoteBgResource(mBgColorId);
    }
    /**
     * 获取笔记背景颜色ID
     * @return 背景颜色ID
     */
    public int getBgColorId() {
        return mBgColorId;
    }
    /**
     * 获取笔记标题背景资源ID
     * @return 标题背景资源ID
     */
    public int getTitleBgResId() {
        return NoteBgResources.getNoteTitleBgResource(mBgColorId);
    }
    /**
     * 获取笔记模式（普通模式/清单模式）
     * @return 笔记模式
     */
    public int getCheckListMode() {
        return mMode;
    }
    /**
     * 获取笔记ID
     * @return 笔记ID
     */
    public long getNoteId() {
        return mNoteId;
    }
    /**
     * 获取笔记所属文件夹ID
     * @return 文件夹ID
     */
    public long getFolderId() {
        return mFolderId;
    }
    /**
     * 获取笔记小部件ID
     * @return 小部件ID
     */
    public int getWidgetId() {
        return mWidgetId;
    }
    /**
     * 获取笔记小部件类型
     * @return 小部件类型
     */
    public int getWidgetType() {
        return mWidgetType;
    }
    /**
     * 笔记设置变化监听器
     * 用于监听笔记设置变化事件
     */
    public interface NoteSettingChangedListener {
        /**
-         * 当笔记背景颜色改变时调用
+         * Called when the background color of current note has just changed
         */
        void onBackgroundColorChanged();
        /**
-         * 当用户设置或取消提醒时调用
+         * Called when user set clock
         * @param date 提醒日期时间
         * @param set 是否设置提醒
         */
        void onClockAlertChanged(long date, boolean set);
        /**
-         * 当笔记小部件内容需要更新时调用
+         * Call when user create note from widget
         */
        void onWidgetChanged();
        /**
-         * 当切换笔记模式（普通模式/清单模式）时调用
+         * Call when switch between check list mode and normal mode
-         * @param oldMode 切换前的模式
+         * @param oldMode is previous mode before change
-         * @param newMode 切换后的模式
+         * @param newMode is new mode
         */
        void onCheckListModeChanged(int oldMode, int newMode);
    }
--- a/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
+++ b/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
@ -36,20 +36,11 @@ import java.io.IOException;
 import java.io.PrintStream;
 /**
 * 备份工具 - 用于将笔记数据导出为文本文件
 * 采用单例模式设计，确保全局只有一个备份工具实例
 */
 public class BackupUtils {
-    private static final String TAG = "BackupUtils";  // 日志标签
+    private static final String TAG = "BackupUtils";
-    /** 单例实例 */
+    // Singleton stuff
-    private static BackupUtils sInstance;  // 单例实例
+    private static BackupUtils sInstance;
    /**
     * 获取BackupUtils单例实例
     * @param context 上下文对象
     * @return BackupUtils单例实例
     */
    public static synchronized BackupUtils getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new BackupUtils(context);
@ -57,109 +48,83 @@ public class BackupUtils {
        return sInstance;
    }
    /** 备份或恢复状态常量 */
    /** SD卡未挂载 */
    public static final int STATE_SD_CARD_UNMOUONTED           = 0;  // SD卡未挂载
    /** 备份文件不存在 */
    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;  // 备份文件不存在
    /** 数据格式损坏，可能被其他程序修改 */
    public static final int STATE_DATA_DESTROIED               = 2;  // 数据格式错误
    /** 运行时异常导致恢复或备份失败 */
    public static final int STATE_SYSTEM_ERROR                 = 3;  // 系统错误
    /** 备份或恢复成功 */
    public static final int STATE_SUCCESS                      = 4;  // 操作成功
    /** 文本导出对象 */
    private TextExport mTextExport;
    /**
-     * 私有构造方法 - 初始化文本导出工具
+     * Following states are signs to represents backup or restore
-     * @param context 上下文对象
+     * status
     */
    // Currently, the sdcard is not mounted
    public static final int STATE_SD_CARD_UNMOUONTED           = 0;
    // The backup file not exist
    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;
    // The data is not well formated, may be changed by other programs
    public static final int STATE_DATA_DESTROIED               = 2;
    // Some run-time exception which causes restore or backup fails
    public static final int STATE_SYSTEM_ERROR                 = 3;
    // Backup or restore success
    public static final int STATE_SUCCESS                      = 4;
    private TextExport mTextExport;
    private BackupUtils(Context context) {
        mTextExport = new TextExport(context);
    }
    /**
     * 检查外部存储是否已挂载。
     * @return 可用返回true
     */
    private static boolean externalStorageAvailable() {
        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
    }
    /**
     * 将笔记导出为文本文件
     * @return 导出状态码
     */
    public int exportToText() {
        return mTextExport.exportToText();
    }
    /**
     * 获取导出的文本文件名
     * @return 导出的文本文件名
     */
    public String getExportedTextFileName() {
        return mTextExport.mFileName;
    }
    /**
     * 获取导出的文本文件目录
     * @return 导出的文本文件目录
     */
    public String getExportedTextFileDir() {
        return mTextExport.mFileDirectory;
    }
    /**
     * 文本导出内部类：遍历 note/data 表，将结果写入 SD 卡上的 txt 文件。
     */
    private static class TextExport {
        // 笔记查询投影列
        private static final String[] NOTE_PROJECTION = {
-                NoteColumns.ID,               // 笔记ID
+                NoteColumns.ID,
-                NoteColumns.MODIFIED_DATE,    // 修改日期
+                NoteColumns.MODIFIED_DATE,
-                NoteColumns.SNIPPET,          // 笔记摘要
+                NoteColumns.SNIPPET,
-                NoteColumns.TYPE              // 笔记类型
+                NoteColumns.TYPE
        };
-        // 笔记查询结果列索引
+        private static final int NOTE_COLUMN_ID = 0;
-        private static final int NOTE_COLUMN_ID = 0;                // ID列索引
+
-        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;     // 修改日期列索引
+        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
-        private static final int NOTE_COLUMN_SNIPPET = 2;           // 摘要列索引
+
        private static final int NOTE_COLUMN_SNIPPET = 2;
        // 笔记数据查询投影列
        private static final String[] DATA_PROJECTION = {
-                DataColumns.CONTENT,          // 内容
+                DataColumns.CONTENT,
-                DataColumns.MIME_TYPE,        // MIME类型
+                DataColumns.MIME_TYPE,
-                DataColumns.DATA1,            // 数据1
+                DataColumns.DATA1,
-                DataColumns.DATA2,            // 数据2
+                DataColumns.DATA2,
-                DataColumns.DATA3,            // 数据3
+                DataColumns.DATA3,
-                DataColumns.DATA4,            // 数据4
+                DataColumns.DATA4,
        };
-        // 笔记数据查询结果列索引
+        private static final int DATA_COLUMN_CONTENT = 0;
-        private static final int DATA_COLUMN_CONTENT = 0;           // 内容列索引
+
-        private static final int DATA_COLUMN_MIME_TYPE = 1;         // MIME类型列索引
+        private static final int DATA_COLUMN_MIME_TYPE = 1;
-        private static final int DATA_COLUMN_CALL_DATE = 2;         // 通话日期列索引
+
-        private static final int DATA_COLUMN_PHONE_NUMBER = 4;      // 电话号码列索引
+        private static final int DATA_COLUMN_CALL_DATE = 2;
        private static final int DATA_COLUMN_PHONE_NUMBER = 4;
        // 文本格式模板
        private final String [] TEXT_FORMAT;
-        private static final int FORMAT_FOLDER_NAME          = 0;    // 文件夹名称格式
+        private static final int FORMAT_FOLDER_NAME          = 0;
-        private static final int FORMAT_NOTE_DATE            = 1;    // 笔记日期格式
+        private static final int FORMAT_NOTE_DATE            = 1;
-        private static final int FORMAT_NOTE_CONTENT         = 2;    // 笔记内容格式
+        private static final int FORMAT_NOTE_CONTENT         = 2;
-        // 成员变量
+        private Context mContext;
-        private Context mContext;           // 上下文对象
+        private String mFileName;
-        private String mFileName;           // 导出文件名
+        private String mFileDirectory;
        private String mFileDirectory;      // 导出文件目录
        /**
         * 构造方法 - 初始化文本导出工具
         * @param context 上下文对象
         */
        public TextExport(Context context) {
            TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
            mContext = context;
@ -167,22 +132,15 @@ public class BackupUtils {
            mFileDirectory = "";
        }
        /**
         * 获取指定ID的文本格式模板
         * @param id 格式模板ID
         * @return 文本格式模板
         */
        private String getFormat(int id) {
            return TEXT_FORMAT[id];
        }
        /**
-         * 将指定ID的文件夹及其包含的笔记导出为文本格式
+         * Export the folder identified by folder id to text
         * @param folderId 文件夹ID
         * @param ps 输出流对象
         */
        private void exportFolderToText(String folderId, PrintStream ps) {
-            // 查询该文件夹下的所有笔记
+            // Query notes belong to this folder
            Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                    NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
                        folderId
@ -191,11 +149,11 @@ public class BackupUtils {
            if (notesCursor != null) {
                if (notesCursor.moveToFirst()) {
                    do {
-                        // 打印笔记的最后修改日期
+                        // Print note's last modified date
                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                mContext.getString(R.string.format_datetime_mdhm),
                                notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // 查询该笔记的详细数据
+                        // Query data belong to this note
                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                        exportNoteToText(noteId, ps);
                    } while (notesCursor.moveToNext());
@ -205,12 +163,9 @@ public class BackupUtils {
        }
        /**
-         * 将指定ID的笔记导出到输出流中
+         * Export note identified by id to a print stream
         * @param noteId 笔记ID
         * @param ps 输出流对象
         */
        private void exportNoteToText(String noteId, PrintStream ps) {
            // 查询该笔记的详细数据
            Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
                    DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
                        noteId
@ -220,29 +175,26 @@ public class BackupUtils {
                if (dataCursor.moveToFirst()) {
                    do {
                        String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
                        // 处理通话记录类型笔记
                        if (DataConstants.CALL_NOTE.equals(mimeType)) {
                            // Print phone number
                            String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);
                            long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);
                            String location = dataCursor.getString(DATA_COLUMN_CONTENT);
                            // 打印电话号码
                            if (!TextUtils.isEmpty(phoneNumber)) {
                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                        phoneNumber));
                            }
-                            // 打印通话日期
+                            // Print call date
                            ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
                                    .format(mContext.getString(R.string.format_datetime_mdhm),
                                            callDate)));
-                            // 打印通话附件位置
+                            // Print call attachment location
                            if (!TextUtils.isEmpty(location)) {
                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                        location));
                            }
-                        } 
+                        } else if (DataConstants.NOTE.equals(mimeType)) {
                        // 处理普通类型笔记
                        else if (DataConstants.NOTE.equals(mimeType)) {
                            String content = dataCursor.getString(DATA_COLUMN_CONTENT);
                            if (!TextUtils.isEmpty(content)) {
                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
@ -253,10 +205,10 @@ public class BackupUtils {
                }
                dataCursor.close();
            }
-            // 在笔记之间打印分隔符
+            // print a line separator between note
            try {
                ps.write(new byte[] {
-                        Character.LINE_SEPARATOR, Character.LINE_SEPARATOR
+                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
                });
            } catch (IOException e) {
                Log.e(TAG, e.toString());
@ -264,24 +216,20 @@ public class BackupUtils {
        }
        /**
-         * 将所有笔记导出为用户可读的文本格式
+         * Note will be exported as text which is user readable
         * @return 导出状态码
         */
        public int exportToText() {
            // 检查外部存储是否可用
            if (!externalStorageAvailable()) {
                Log.d(TAG, "Media was not mounted");
                return STATE_SD_CARD_UNMOUONTED;
            }
            // 获取输出流
            PrintStream ps = getExportToTextPrintStream();
            if (ps == null) {
                Log.e(TAG, "get print stream error");
                return STATE_SYSTEM_ERROR;
            }
-            
+            // First export folder and its notes
            // 首先导出文件夹及其包含的笔记
            Cursor folderCursor = mContext.getContentResolver().query(
                    Notes.CONTENT_NOTE_URI,
                    NOTE_PROJECTION,
@ -292,9 +240,8 @@ public class BackupUtils {
            if (folderCursor != null) {
                if (folderCursor.moveToFirst()) {
                    do {
-                        // 打印文件夹名称
+                        // Print folder's name
                        String folderName = "";
                        // 特殊处理通话记录文件夹
                        if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
                            folderName = mContext.getString(R.string.call_record_folder_name);
                        } else {
@ -303,8 +250,6 @@ public class BackupUtils {
                        if (!TextUtils.isEmpty(folderName)) {
                            ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
                        }
                        // 导出该文件夹下的所有笔记
                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);
                        exportFolderToText(folderId, ps);
                    } while (folderCursor.moveToNext());
@ -312,7 +257,7 @@ public class BackupUtils {
                folderCursor.close();
            }
-            // 导出根目录下的笔记
+            // Export notes in root's folder
            Cursor noteCursor = mContext.getContentResolver().query(
                    Notes.CONTENT_NOTE_URI,
                    NOTE_PROJECTION,
@ -322,42 +267,33 @@ public class BackupUtils {
            if (noteCursor != null) {
                if (noteCursor.moveToFirst()) {
                    do {
                        // 打印笔记修改日期
                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                mContext.getString(R.string.format_datetime_mdhm),
                                noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
-                        // 导出笔记内容
+                        // Query data belong to this note
                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);
                        exportNoteToText(noteId, ps);
                    } while (noteCursor.moveToNext());
                }
                noteCursor.close();
            }
            // 关闭输出流
            ps.close();
            return STATE_SUCCESS;
        }
        /**
-         * 获取指向导出文本文件的输出流
+         * Get a print stream pointed to the file {@generateExportedTextFile}
         * @return 输出流对象，失败则返回null
         */
        private PrintStream getExportToTextPrintStream() {
            // 生成导出文件
            File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
                    R.string.file_name_txt_format);
            if (file == null) {
                Log.e(TAG, "create file to exported failed");
                return null;
            }
            // 保存文件名和目录信息
            mFileName = file.getName();
            mFileDirectory = mContext.getString(R.string.file_path);
            // 创建输出流
            PrintStream ps = null;
            try {
                FileOutputStream fos = new FileOutputStream(file);
@ -374,27 +310,19 @@ public class BackupUtils {
    }
    /**
-     * 在SD卡上生成用于存储导出数据的文本文件
+     * Generate the text file to store imported data
     * @param context 上下文对象
     * @param filePathResId 文件路径资源ID
     * @param fileNameFormatResId 文件名格式资源ID
     * @return 创建的文件对象，失败则返回null
     */
    private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
        StringBuilder sb = new StringBuilder();
        // 构建文件路径：SD卡根目录 + 自定义路径
        sb.append(Environment.getExternalStorageDirectory());
        sb.append(context.getString(filePathResId));
        File filedir = new File(sb.toString());
        // 构建完整文件名：路径 + 格式化文件名（包含当前日期）
        sb.append(context.getString(
                fileNameFormatResId,
                DateFormat.format(context.getString(R.string.format_date_ymd),
                        System.currentTimeMillis())));
        File file = new File(sb.toString());
        // 创建目录和文件
        try {
            if (!filedir.exists()) {
                filedir.mkdir();
--- a/src/Notes-master/src/net/micode/notes/tool/DataUtils.java
+++ b/src/Notes-master/src/net/micode/notes/tool/DataUtils.java
@ -34,28 +34,9 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
 import java.util.ArrayList;
 import java.util.HashSet;
-/**
+
 * 数据工具类。
 * <p>职责：封装常用的数据库批量操作（删除、移动、查询校验等），统一错误处理与日志。</p>
 * <p>使用场景：列表/编辑/同步等需要对 note 表或 data 表做批量操作时复用。</p>
 */
 /**
 * 数据工具 - 提供笔记数据的各种操作工具方法
 * 包含批量删除、移动笔记、文件夹管理、小部件处理等功能
 */
 public class DataUtils {
    /**
     * 日志标签
     */
    public static final String TAG = "DataUtils";
    /**
     * 批量删除笔记。
     *
     * @param resolver ContentResolver对象
     * @param ids 要删除的笔记ID集合
     * @return 删除成功返回true，否则返回false
     */
    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
        if (ids == null) {
            Log.d(TAG, "the ids is null");
@ -91,13 +72,6 @@ public class DataUtils {
        return false;
    }
    /**
     * 将单个笔记从源文件夹移动到目标文件夹
     * @param resolver 内容解析器
     * @param id 笔记ID
     * @param srcFolderId 源文件夹ID
     * @param desFolderId 目标文件夹ID
     */
    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
        ContentValues values = new ContentValues();
        values.put(NoteColumns.PARENT_ID, desFolderId);
@ -106,13 +80,6 @@ public class DataUtils {
        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
    }
    /**
     * 批量将笔记移动到指定文件夹
     * @param resolver 内容解析器
     * @param ids 要移动的笔记ID集合
     * @param folderId 目标文件夹ID
     * @return 是否移动成功
     */
    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
            long folderId) {
        if (ids == null) {
@ -145,9 +112,7 @@ public class DataUtils {
    }
    /**
-     * 获取用户创建的文件夹数量（不包括系统文件夹）
+     * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
     * @param resolver 内容解析器
     * @return 用户文件夹数量
     */
    public static int getUserFolderCount(ContentResolver resolver) {
        Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
@ -171,13 +136,6 @@ public class DataUtils {
        return count;
    }
    /**
     * 检查指定ID和类型的笔记是否在数据库中可见（不在垃圾桶中）
     * @param resolver 内容解析器
     * @param noteId 笔记ID
     * @param type 笔记类型
     * @return 是否可见
     */
    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                null,
@ -195,12 +153,6 @@ public class DataUtils {
        return exist;
    }
    /**
     * 检查指定ID的笔记是否存在于数据库中
     * @param resolver 内容解析器
     * @param noteId 笔记ID
     * @return 是否存在
     */
    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                null, null, null, null);
@ -215,12 +167,6 @@ public class DataUtils {
        return exist;
    }
    /**
     * 检查指定ID的笔记数据是否存在于数据库中
     * @param resolver 内容解析器
     * @param dataId 数据ID
     * @return 是否存在
     */
    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
                null, null, null, null);
@ -235,12 +181,6 @@ public class DataUtils {
        return exist;
    }
    /**
     * 检查指定名称的可见文件夹是否存在（不在垃圾桶中）
     * @param resolver 内容解析器
     * @param name 文件夹名称
     * @return 是否存在
     */
    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
@ -257,12 +197,6 @@ public class DataUtils {
        return exist;
    }
    /**
     * 获取与指定文件夹关联的所有应用小部件
     * @param resolver 内容解析器
     * @param folderId 文件夹ID
     * @return 应用小部件属性集合
     */
    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
@ -290,13 +224,6 @@ public class DataUtils {
        return set;
    }
    /**
     * 通过笔记ID获取电话号码
     * 用于通话记录笔记的电话号码获取
     * @param resolver 内容解析器
     * @param noteId 笔记ID
     * @return 电话号码
     */
    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                new String [] { CallNote.PHONE_NUMBER },
@ -316,14 +243,6 @@ public class DataUtils {
        return "";
    }
    /**
     * 通过电话号码和通话日期获取笔记ID
     * 用于通话记录笔记的查询
     * @param resolver 内容解析器
     * @param phoneNumber 电话号码
     * @param callDate 通话日期时间戳
     * @return 笔记ID
     */
    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
                new String [] { CallNote.NOTE_ID },
@ -345,13 +264,6 @@ public class DataUtils {
        return 0;
    }
    /**
     * 通过笔记ID获取笔记摘要
     * @param resolver 内容解析器
     * @param noteId 笔记ID
     * @return 笔记摘要
     * @throws IllegalArgumentException 如果笔记不存在
     */
    public static String getSnippetById(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
                new String [] { NoteColumns.SNIPPET },
@ -370,12 +282,6 @@ public class DataUtils {
        throw new IllegalArgumentException("Note is not found with id: " + noteId);
    }
    /**
     * 格式化笔记摘要
     * 去除首尾空格并只保留第一行内容
     * @param snippet 原始笔记摘要
     * @return 格式化后的笔记摘要
     */
    public static String getFormattedSnippet(String snippet) {
        if (snippet != null) {
            snippet = snippet.trim();
--- a/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
+++ b/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
@ -16,285 +16,98 @@
 package net.micode.notes.tool;
 /**
 * Google Tasks字符串工具 - 定义Google Tasks同步相关的所有字符串常量
 * 包含JSON字段名、操作类型、文件夹名称等用于Google Tasks API交互和本地数据处理的常量
 */
 public class GTaskStringUtils {
    /**
     * JSON字段：操作ID
     */
    public final static String GTASK_JSON_ACTION_ID = "action_id";
    /**
     * JSON字段：操作列表
     */
    public final static String GTASK_JSON_ACTION_LIST = "action_list";
    /**
     * JSON字段：操作类型
     */
    public final static String GTASK_JSON_ACTION_TYPE = "action_type";
    /**
     * JSON字段：操作类型 - 创建
     */
    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
    /**
     * JSON字段：操作类型 - 获取所有
     */
    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
    /**
     * JSON字段：操作类型 - 移动
     */
    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
    /**
     * JSON字段：操作类型 - 更新
     */
    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
    /**
     * JSON字段：创建者ID
     */
    public final static String GTASK_JSON_CREATOR_ID = "creator_id";
    /**
     * JSON字段：子实体
     */
    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
    /**
     * JSON字段：客户端版本
     */
    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
    /**
     * JSON字段：已完成
     */
    public final static String GTASK_JSON_COMPLETED = "completed";
    /**
     * JSON字段：当前列表ID
     */
    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
    /**
     * JSON字段：默认列表ID
     */
    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
    /**
     * JSON字段：已删除
     */
    public final static String GTASK_JSON_DELETED = "deleted";
    /**
     * JSON字段：目标列表
     */
    public final static String GTASK_JSON_DEST_LIST = "dest_list";
    /**
     * JSON字段：目标父节点
     */
    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
    /**
     * JSON字段：目标父节点类型
     */
    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
    /**
     * JSON字段：实体增量
     */
    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
    /**
     * JSON字段：实体类型
     */
    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
    /**
     * JSON字段：获取已删除
     */
    public final static String GTASK_JSON_GET_DELETED = "get_deleted";
    /**
     * JSON字段：ID
     */
    public final static String GTASK_JSON_ID = "id";
    /**
     * JSON字段：索引
     */
    public final static String GTASK_JSON_INDEX = "index";
    /**
     * JSON字段：最后修改时间
     */
    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
    /**
     * JSON字段：最新同步点
     */
    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
    /**
     * JSON字段：列表ID
     */
    public final static String GTASK_JSON_LIST_ID = "list_id";
    /**
     * JSON字段：列表集合
     */
    public final static String GTASK_JSON_LISTS = "lists";
    /**
     * JSON字段：名称
     */
    public final static String GTASK_JSON_NAME = "name";
    /**
     * JSON字段：新ID
     */
    public final static String GTASK_JSON_NEW_ID = "new_id";
    /**
     * JSON字段：备注
     */
    public final static String GTASK_JSON_NOTES = "notes";
    /**
     * JSON字段：父节点ID
     */
    public final static String GTASK_JSON_PARENT_ID = "parent_id";
    /**
     * JSON字段：前一个兄弟节点ID
     */
    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
    /**
     * JSON字段：结果
     */
    public final static String GTASK_JSON_RESULTS = "results";
    /**
     * JSON字段：源列表
     */
    public final static String GTASK_JSON_SOURCE_LIST = "source_list";
    /**
     * JSON字段：任务集合
     */
    public final static String GTASK_JSON_TASKS = "tasks";
    /**
     * JSON字段：类型
     */
    public final static String GTASK_JSON_TYPE = "type";
    /**
     * JSON字段：类型 - 组
     */
    public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
    /**
     * JSON字段：类型 - 任务
     */
    public final static String GTASK_JSON_TYPE_TASK = "TASK";
    /**
     * JSON字段：用户
     */
    public final static String GTASK_JSON_USER = "user";
    /**
     * MIUI文件夹前缀
     */
    public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
    /**
     * 默认文件夹名称
     */
    public final static String FOLDER_DEFAULT = "Default";
    /**
     * 通话记录文件夹名称
     */
    public final static String FOLDER_CALL_NOTE = "Call_Note";
    /**
     * 元数据文件夹名称
     */
    public final static String FOLDER_META = "METADATA";
    /**
     * 元数据头：Google Tasks ID
     */
    public final static String META_HEAD_GTASK_ID = "meta_gid";
    /**
     * 元数据头：笔记
     */
    public final static String META_HEAD_NOTE = "meta_note";
    /**
     * 元数据头：数据
     */
    public final static String META_HEAD_DATA = "meta_data";
    /**
     * 元数据笔记名称
     */
    public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
 }
--- a/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
+++ b/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
@ -22,76 +22,24 @@ import android.preference.PreferenceManager;
 import net.micode.notes.R;
 import net.micode.notes.ui.NotesPreferenceActivity;
 /**
 * 资源解析工具 - 管理笔记应用的UI资源
 * 包括背景资源、字体大小、小部件资源等
 */
 public class ResourceParser {
    /**
     * 笔记背景颜色常量 - 黄色
     */
    public static final int YELLOW           = 0;
    /**
     * 笔记背景颜色常量 - 蓝色
     */
    public static final int BLUE             = 1;
    /**
     * 笔记背景颜色常量 - 白色
     */
    public static final int WHITE            = 2;
    /**
     * 笔记背景颜色常量 - 绿色
     */
    public static final int GREEN            = 3;
    /**
     * 笔记背景颜色常量 - 红色
     */
    public static final int RED              = 4;
    /**
     * 默认笔记背景颜色
     */
    public static final int BG_DEFAULT_COLOR = YELLOW;
    /**
     * 字体大小常量 - 小
     */
    public static final int TEXT_SMALL       = 0;
    /**
     * 字体大小常量 - 中
     */
    public static final int TEXT_MEDIUM      = 1;
    /**
     * 字体大小常量 - 大
     */
    public static final int TEXT_LARGE       = 2;
    /**
     * 字体大小常量 - 超大
     */
    public static final int TEXT_SUPER       = 3;
    /**
     * 默认字体大小
     */
    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
    /**
     * 笔记编辑背景资源类
     * 管理笔记编辑界面的背景资源
     */
    public static class NoteBgResources {
        /**
         * 笔记编辑主背景资源数组
         * 索引对应背景颜色常量
         */
        private final static int [] BG_EDIT_RESOURCES = new int [] {
            R.drawable.edit_yellow,
            R.drawable.edit_blue,
@ -100,10 +48,6 @@ public class ResourceParser {
            R.drawable.edit_red
        };
        /**
         * 笔记编辑标题栏背景资源数组
         * 索引对应背景颜色常量
         */
        private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
            R.drawable.edit_title_yellow,
            R.drawable.edit_title_blue,
@ -112,31 +56,15 @@ public class ResourceParser {
            R.drawable.edit_title_red
        };
        /**
         * 获取笔记编辑主背景资源
         * @param id 背景颜色ID
         * @return 背景资源ID
         */
        public static int getNoteBgResource(int id) {
            return BG_EDIT_RESOURCES[id];
        }
        /**
         * 获取笔记编辑标题栏背景资源
         * @param id 背景颜色ID
         * @return 标题栏背景资源ID
         */
        public static int getNoteTitleBgResource(int id) {
            return BG_EDIT_TITLE_RESOURCES[id];
        }
    }
    /**
     * 获取默认背景颜色ID
     * 根据用户偏好设置决定是使用随机颜色还是默认颜色
     * @param context 上下文
     * @return 背景颜色ID
     */
    public static int getDefaultBgId(Context context) {
        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
@ -146,15 +74,7 @@ public class ResourceParser {
        }
    }
    /**
     * 笔记列表项背景资源类
     * 管理笔记列表中不同位置项的背景资源
     */
    public static class NoteItemBgResources {
        /**
         * 列表首项背景资源数组
         * 索引对应背景颜色常量
         */
        private final static int [] BG_FIRST_RESOURCES = new int [] {
            R.drawable.list_yellow_up,
            R.drawable.list_blue_up,
@ -163,10 +83,6 @@ public class ResourceParser {
            R.drawable.list_red_up
        };
        /**
         * 列表中间项背景资源数组
         * 索引对应背景颜色常量
         */
        private final static int [] BG_NORMAL_RESOURCES = new int [] {
            R.drawable.list_yellow_middle,
            R.drawable.list_blue_middle,
@ -175,10 +91,6 @@ public class ResourceParser {
            R.drawable.list_red_middle
        };
        /**
         * 列表末项背景资源数组
         * 索引对应背景颜色常量
         */
        private final static int [] BG_LAST_RESOURCES = new int [] {
            R.drawable.list_yellow_down,
            R.drawable.list_blue_down,
@ -187,10 +99,6 @@ public class ResourceParser {
            R.drawable.list_red_down,
        };
        /**
         * 列表单项背景资源数组
         * 索引对应背景颜色常量
         */
        private final static int [] BG_SINGLE_RESOURCES = new int [] {
            R.drawable.list_yellow_single,
            R.drawable.list_blue_single,
@ -199,60 +107,28 @@ public class ResourceParser {
            R.drawable.list_red_single
        };
        /**
         * 获取列表首项背景资源
         * @param id 背景颜色ID
         * @return 首项背景资源ID
         */
        public static int getNoteBgFirstRes(int id) {
            return BG_FIRST_RESOURCES[id];
        }
        /**
         * 获取列表末项背景资源
         * @param id 背景颜色ID
         * @return 末项背景资源ID
         */
        public static int getNoteBgLastRes(int id) {
            return BG_LAST_RESOURCES[id];
        }
        /**
         * 获取列表单项背景资源
         * @param id 背景颜色ID
         * @return 单项背景资源ID
         */
        public static int getNoteBgSingleRes(int id) {
            return BG_SINGLE_RESOURCES[id];
        }
        /**
         * 获取列表中间项背景资源
         * @param id 背景颜色ID
         * @return 中间项背景资源ID
         */
        public static int getNoteBgNormalRes(int id) {
            return BG_NORMAL_RESOURCES[id];
        }
        /**
         * 获取文件夹项背景资源
         * @return 文件夹背景资源ID
         */
        public static int getFolderBgRes() {
            return R.drawable.list_folder;
        }
    }
    /**
     * 小部件背景资源类
     * 管理不同尺寸小部件的背景资源
     */
    public static class WidgetBgResources {
        /**
         * 2x尺寸小部件背景资源数组
         * 索引对应背景颜色常量
         */
        private final static int [] BG_2X_RESOURCES = new int [] {
            R.drawable.widget_2x_yellow,
            R.drawable.widget_2x_blue,
@ -261,19 +137,10 @@ public class ResourceParser {
            R.drawable.widget_2x_red,
        };
        /**
         * 获取2x尺寸小部件背景资源
         * @param id 背景颜色ID
         * @return 2x小部件背景资源ID
         */
        public static int getWidget2xBgResource(int id) {
            return BG_2X_RESOURCES[id];
        }
        /**
         * 4x尺寸小部件背景资源数组
         * 索引对应背景颜色常量
         */
        private final static int [] BG_4X_RESOURCES = new int [] {
            R.drawable.widget_4x_yellow,
            R.drawable.widget_4x_blue,
@ -282,48 +149,31 @@ public class ResourceParser {
            R.drawable.widget_4x_red
        };
        /**
         * 获取4x尺寸小部件背景资源
         * @param id 背景颜色ID
         * @return 4x小部件背景资源ID
         */
        public static int getWidget4xBgResource(int id) {
            return BG_4X_RESOURCES[id];
        }
    }
    /**
     * 文本外观资源类
     * 管理不同字体大小的文本样式资源
     */
    public static class TextAppearanceResources {
        /**
         * 文本外观资源数组
         * 索引对应字体大小常量
         */
        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
-            R.style.TextAppearanceNormal,  // TEXT_SMALL
+            R.style.TextAppearanceNormal,
-            R.style.TextAppearanceMedium,   // TEXT_MEDIUM
+            R.style.TextAppearanceMedium,
-            R.style.TextAppearanceLarge,    // TEXT_LARGE
+            R.style.TextAppearanceLarge,
-            R.style.TextAppearanceSuper     // TEXT_SUPER
+            R.style.TextAppearanceSuper
        };
        /**
         * 获取文本外观资源
         * @param id 字体大小ID
         * @return 文本外观资源ID
         */
        public static int getTexAppearanceResource(int id) {
            /**
             * 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}
             */
            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
                return BG_DEFAULT_FONT_SIZE;
            }
            return TEXTAPPEARANCE_RESOURCES[id];
        }
        /**
         * 获取文本外观资源数量
         * @return 文本外观资源数量
         */
        public static int getResourcesSize() {
            return TEXTAPPEARANCE_RESOURCES.length;
        }
--- a/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
@ -39,51 +39,22 @@ import net.micode.notes.tool.DataUtils;
 import java.io.IOException;
-/**
+
 * 闹钟提醒活动
 * 当笔记提醒时间到达时显示提醒界面
 */
 /**
 * 闹钟提醒活动
 * 用于显示笔记提醒对话框并播放闹钟声音
 */
 public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
    /**
     * 笔记ID
     */
    private long mNoteId;
    /**
     * 笔记摘要内容
     */
    private String mSnippet;
    /**
     * 摘要预览最大长度
     */
    private static final int SNIPPET_PREW_MAX_LEN = 60;
    /**
     * 媒体播放器，用于播放闹钟声音
     */
    MediaPlayer mPlayer;
    /**
     * 创建活动时调用的方法
     * 设置窗口特性、处理意图数据、初始化播放器并显示提醒对话框
     * @param savedInstanceState 保存的实例状态
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        final Window win = getWindow();
        // 允许在锁屏时显示
        win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
        if (!isScreenOn()) {
            // 如果屏幕关闭，添加标志唤醒屏幕并保持点亮
            win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
                    | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
                    | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
@ -93,11 +64,8 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
        Intent intent = getIntent();
        try {
            // 从Intent中获取笔记ID
            mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
            // 获取笔记摘要
            mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
            // 限制摘要长度
            mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
                    SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
                    : mSnippet;
@ -106,9 +74,7 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
            return;
        }
        // 初始化媒体播放器
        mPlayer = new MediaPlayer();
        // 检查笔记是否可见，如果可见则显示对话框并播放声音
        if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
            showActionDialog();
            playAlarmSound();
@ -117,28 +83,17 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
        }
    }
    /**
     * 检查屏幕是否开启
     * @return 屏幕是否开启
     */
    private boolean isScreenOn() {
        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
        return pm.isScreenOn();
    }
    /**
     * 播放闹钟声音
     * 获取系统默认闹钟铃声并设置循环播放
     */
    private void playAlarmSound() {
        // 获取系统默认闹钟铃声URI
        Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
        // 获取静音模式下受影响的音频流
        int silentModeStreams = Settings.System.getInt(getContentResolver(),
                Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
        // 设置音频流类型
        if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
            mPlayer.setAudioStreamType(silentModeStreams);
        } else {
@ -147,75 +102,57 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
        try {
            mPlayer.setDataSource(this, url);
            mPlayer.prepare();
-            mPlayer.setLooping(true);  // 设置循环播放
+            mPlayer.setLooping(true);
            mPlayer.start();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalStateException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * 显示提醒对话框
     * 对话框显示笔记摘要，并根据屏幕状态提供不同的按钮选项
     */
    private void showActionDialog() {
        AlertDialog.Builder dialog = new AlertDialog.Builder(this);
        dialog.setTitle(R.string.app_name);
-        dialog.setMessage(mSnippet);  // 显示笔记摘要
+        dialog.setMessage(mSnippet);
-        dialog.setPositiveButton(R.string.notealert_ok, this);  // 确定按钮
+        dialog.setPositiveButton(R.string.notealert_ok, this);
        if (isScreenOn()) {
            // 如果屏幕已开启，显示"进入"按钮
            dialog.setNegativeButton(R.string.notealert_enter, this);
        }
        // 显示对话框并设置消失监听器
        dialog.show().setOnDismissListener(this);
    }
    /**
     * 处理对话框按钮点击事件
     * @param dialog 对话框实例
     * @param which 被点击的按钮ID
     */
    public void onClick(DialogInterface dialog, int which) {
        switch (which) {
            case DialogInterface.BUTTON_NEGATIVE:
                // 点击"进入"按钮，打开笔记编辑界面查看完整笔记
                Intent intent = new Intent(this, NoteEditActivity.class);
                intent.setAction(Intent.ACTION_VIEW);
                intent.putExtra(Intent.EXTRA_UID, mNoteId);
                startActivity(intent);
                break;
            default:
                // 点击"确定"按钮，不执行额外操作
                break;
        }
    }
    /**
     * 处理对话框消失事件
     * 停止闹钟声音并结束活动
     * @param dialog 对话框实例
     */
    public void onDismiss(DialogInterface dialog) {
-        stopAlarmSound();  // 停止闹钟声音
+        stopAlarmSound();
-        finish();          // 结束活动
+        finish();
    }
    /**
     * 停止闹钟声音
     * 释放媒体播放器资源
     */
    private void stopAlarmSound() {
        if (mPlayer != null) {
            mPlayer.stop();
-            mPlayer.release();  // 释放资源
+            mPlayer.release();
-            mPlayer = null;      // 清空引用
+            mPlayer = null;
        }
    }
 }
--- a/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
@ -27,42 +27,20 @@ import android.database.Cursor;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
-/**
+
 * 闹钟初始化接收器
 * 在系统启动时重新设置所有笔记的提醒
 */
 /**
 * 闹钟初始化广播接收器
 * 用于系统启动或其他触发事件时重新设置所有笔记的闹钟提醒
 */
 public class AlarmInitReceiver extends BroadcastReceiver {
    /**
     * 数据库查询投影
     * 只查询需要的列：笔记ID和提醒日期
     */
    private static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,         // 笔记ID
+        NoteColumns.ID,
-        NoteColumns.ALERTED_DATE // 提醒日期
+        NoteColumns.ALERTED_DATE
    };
-    /**
+    private static final int COLUMN_ID                = 0;
-     * 查询结果列索引常量
+    private static final int COLUMN_ALERTED_DATE      = 1;
     */
    private static final int COLUMN_ID                = 0;  // 笔记ID列索引
    private static final int COLUMN_ALERTED_DATE      = 1;  // 提醒日期列索引
    /**
     * 接收广播时调用的方法
     * 重新设置所有未来时间的笔记提醒闹钟
     * @param context 上下文
     * @param intent 接收到的意图
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        long currentDate = System.currentTimeMillis();
        // 查询数据库中所有设置了未来提醒日期的笔记
        Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                PROJECTION,
                NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
@ -72,23 +50,16 @@ public class AlarmInitReceiver extends BroadcastReceiver {
        if (c != null) {
            if (c.moveToFirst()) {
                do {
                    // 获取提醒日期和笔记ID
                    long alertDate = c.getLong(COLUMN_ALERTED_DATE);
                    // 创建闹钟接收器的意图
                    Intent sender = new Intent(context, AlarmReceiver.class);
                    sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
                    // 创建PendingIntent用于触发闹钟
                    PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
                    // 获取闹钟管理器并设置闹钟
                    AlarmManager alermManager = (AlarmManager) context
                            .getSystemService(Context.ALARM_SERVICE);
                    alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
                } while (c.moveToNext());
            }
-            c.close();  // 关闭游标
+            c.close();
        }
    }
 }
--- a/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
@ -20,24 +20,11 @@ import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 /**
 * 闹钟接收器
 * 用于接收闹钟触发事件并启动提醒活动
 */
 public class AlarmReceiver extends BroadcastReceiver {
    /**
     * 接收闹钟触发广播时调用的方法
     * 启动闹钟提醒活动显示笔记提醒
     * @param context 上下文
     * @param intent 接收到的意图，包含笔记ID
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        // 将意图的目标类设置为闹钟提醒活动
        intent.setClass(context, AlarmAlertActivity.class);
        // 添加新任务标志，允许从非活动上下文启动活动
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        // 启动闹钟提醒活动
        context.startActivity(intent);
    }
 }
--- a/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
+++ b/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
@ -28,135 +28,85 @@ import android.view.View;
 import android.widget.FrameLayout;
 import android.widget.NumberPicker;
 /**
 * 日期时间选择器组件
 * 用于在笔记应用中设置提醒时间，支持24小时制和12小时制切换
 * 提供日期、小时、分钟和AM/PM的选择功能
 */
 public class DateTimePicker extends FrameLayout {
    /** 默认启用状态 */
    private static final boolean DEFAULT_ENABLE_STATE = true;
    /** 半天的小时数 */
    private static final int HOURS_IN_HALF_DAY = 12;
    /** 全天的小时数 */
    private static final int HOURS_IN_ALL_DAY = 24;
    /** 一周的天数 */
    private static final int DAYS_IN_ALL_WEEK = 7;
    /** 日期选择器的最小值 */
    private static final int DATE_SPINNER_MIN_VAL = 0;
    /** 日期选择器的最大值 */
    private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
    /** 24小时制小时选择器的最小值 */
    private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
    /** 24小时制小时选择器的最大值 */
    private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
    /** 12小时制小时选择器的最小值 */
    private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
    /** 12小时制小时选择器的最大值 */
    private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
    /** 分钟选择器的最小值 */
    private static final int MINUT_SPINNER_MIN_VAL = 0;
    /** 分钟选择器的最大值 */
    private static final int MINUT_SPINNER_MAX_VAL = 59;
    /** AM/PM选择器的最小值 */
    private static final int AMPM_SPINNER_MIN_VAL = 0;
    /** AM/PM选择器的最大值 */
    private static final int AMPM_SPINNER_MAX_VAL = 1;
    /** 日期选择器 */
    private final NumberPicker mDateSpinner;
    /** 小时选择器 */
    private final NumberPicker mHourSpinner;
    /** 分钟选择器 */
    private final NumberPicker mMinuteSpinner;
    /** AM/PM选择器 */
    private final NumberPicker mAmPmSpinner;
    /** 当前选择的日期 */
    private Calendar mDate;
    /** 日期显示值数组 */
    private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
    /** 是否为上午 */
    private boolean mIsAm;
    /** 是否为24小时制 */
    private boolean mIs24HourView;
    /** 是否启用 */
    private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
    /** 是否正在初始化 */
    private boolean mInitialising;
    /** 日期时间变化监听器 */
    private OnDateTimeChangedListener mOnDateTimeChangedListener;
    /** 日期变化监听器 */
    private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
        @Override
        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            // 根据日期选择器的变化调整当前日期
            mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
            // 更新日期选择器显示
            updateDateControl();
            // 通知日期时间变化
            onDateTimeChanged();
        }
    };
    /** 小时变化监听器 */
    private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
        @Override
        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            boolean isDateChanged = false;
            Calendar cal = Calendar.getInstance();
            if (!mIs24HourView) {
                // 处理12小时制下的日期变更逻辑
                if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
                    // 从下午11点变为12点，日期加1天
                    cal.setTimeInMillis(mDate.getTimeInMillis());
                    cal.add(Calendar.DAY_OF_YEAR, 1);
                    isDateChanged = true;
                } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
                    // 从上午12点变为11点，日期减1天
                    cal.setTimeInMillis(mDate.getTimeInMillis());
                    cal.add(Calendar.DAY_OF_YEAR, -1);
                    isDateChanged = true;
                }
                // 处理12小时制下的AM/PM切换
                if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
                        oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
                    mIsAm = !mIsAm;
                    updateAmPmControl();
                }
            } else {
                // 处理24小时制下的日期变更逻辑
                if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
                    // 从23点变为0点，日期加1天
                    cal.setTimeInMillis(mDate.getTimeInMillis());
                    cal.add(Calendar.DAY_OF_YEAR, 1);
                    isDateChanged = true;
                } else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
                    // 从0点变为23点，日期减1天
                    cal.setTimeInMillis(mDate.getTimeInMillis());
                    cal.add(Calendar.DAY_OF_YEAR, -1);
                    isDateChanged = true;
                }
            }
            // 更新当前小时
            int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
            mDate.set(Calendar.HOUR_OF_DAY, newHour);
            // 通知日期时间变化
            onDateTimeChanged();
            // 如果日期发生变化，更新年、月、日
            if (isDateChanged) {
                setCurrentYear(cal.get(Calendar.YEAR));
                setCurrentMonth(cal.get(Calendar.MONTH));
@ -165,31 +115,21 @@ public class DateTimePicker extends FrameLayout {
        }
    };
    /** 分钟变化监听器 */
    private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
        @Override
        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            int minValue = mMinuteSpinner.getMinValue();
            int maxValue = mMinuteSpinner.getMaxValue();
            int offset = 0;
            // 处理分钟溢出/下溢的情况
            if (oldVal == maxValue && newVal == minValue) {
                // 分钟从59变为0，小时加1
                offset += 1;
            } else if (oldVal == minValue && newVal == maxValue) {
                // 分钟从0变为59，小时减1
                offset -= 1;
            }
            if (offset != 0) {
                // 更新小时
                mDate.add(Calendar.HOUR_OF_DAY, offset);
                mHourSpinner.setValue(getCurrentHour());
                // 更新日期显示
                updateDateControl();
                // 更新AM/PM状态
                int newHour = getCurrentHourOfDay();
                if (newHour >= HOURS_IN_HALF_DAY) {
                    mIsAm = false;
@ -199,78 +139,38 @@ public class DateTimePicker extends FrameLayout {
                    updateAmPmControl();
                }
            }
            // 设置当前分钟
            mDate.set(Calendar.MINUTE, newVal);
            // 通知日期时间变化
            onDateTimeChanged();
        }
    };
    /** AM/PM变化监听器 */
    private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
        @Override
        public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            // 切换AM/PM状态
            mIsAm = !mIsAm;
            // 根据AM/PM状态调整小时
            if (mIsAm) {
                // 从PM切换到AM，小时减12
                mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
            } else {
                // 从AM切换到PM，小时加12
                mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
            }
            // 更新AM/PM选择器显示
            updateAmPmControl();
            // 通知日期时间变化
            onDateTimeChanged();
        }
    };
    /**
     * 日期时间变化监听器接口
     * 用于监听日期时间选择器的变化事件
     */
    public interface OnDateTimeChangedListener {
        /**
         * 当日期时间发生变化时调用
         * @param view 日期时间选择器实例
         * @param year 年
         * @param month 月
         * @param dayOfMonth 日
         * @param hourOfDay 时（24小时制）
         * @param minute 分
         */
        void onDateTimeChanged(DateTimePicker view, int year, int month,
                int dayOfMonth, int hourOfDay, int minute);
    }
    /**
     * 创建一个日期时间选择器实例，使用当前时间和系统默认的时间格式
     * @param context 上下文
     */
    public DateTimePicker(Context context) {
        this(context, System.currentTimeMillis());
    }
    /**
     * 创建一个日期时间选择器实例，使用指定时间和系统默认的时间格式
     * @param context 上下文
     * @param date 指定的时间（毫秒）
     */
    public DateTimePicker(Context context, long date) {
        this(context, date, DateFormat.is24HourFormat(context));
    }
    /**
     * 创建一个日期时间选择器实例，使用指定时间和时间格式
     * @param context 上下文
     * @param date 指定的时间（毫秒）
     * @param is24HourView 是否使用24小时制
     */
    public DateTimePicker(Context context, long date, boolean is24HourView) {
        super(context);
        mDate = Calendar.getInstance();
@ -278,24 +178,19 @@ public class DateTimePicker extends FrameLayout {
        mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
        inflate(context, R.layout.datetime_picker, this);
        // 初始化日期选择器
        mDateSpinner = (NumberPicker) findViewById(R.id.date);
        mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
        mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
        mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
        // 初始化小时选择器
        mHourSpinner = (NumberPicker) findViewById(R.id.hour);
        mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
        // 初始化分钟选择器
        mMinuteSpinner =  (NumberPicker) findViewById(R.id.minute);
        mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
        mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
-        mMinuteSpinner.setOnLongPressUpdateInterval(100); // 设置长按更新间隔
+        mMinuteSpinner.setOnLongPressUpdateInterval(100);
        mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
        // 初始化AM/PM选择器
        String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
        mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
        mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
@ -303,21 +198,19 @@ public class DateTimePicker extends FrameLayout {
        mAmPmSpinner.setDisplayedValues(stringsForAmPm);
        mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
-        // 更新控件到初始状态
+        // update controls to initial state
        updateDateControl();
        updateHourControl();
        updateAmPmControl();
        // 设置时间格式（24小时制/12小时制）
        set24HourView(is24HourView);
-        // 设置初始时间
+        // set to current time
        setCurrentDate(date);
        // 设置启用状态
        setEnabled(isEnabled());
-        // 初始化完成
+        // set the content descriptions
        mInitialising = false;
    }
@ -455,22 +348,14 @@ public class DateTimePicker extends FrameLayout {
        return mDate.get(Calendar.HOUR_OF_DAY);
    }
    /**
     * 获取当前小时（根据时间格式返回适当的表示）
     * @return 当前小时（24小时制返回0-23，12小时制返回1-12）
     */
    private int getCurrentHour() {
        if (mIs24HourView){
            // 24小时制直接返回小时
            return getCurrentHourOfDay();
        } else {
            // 12小时制需要转换
            int hour = getCurrentHourOfDay();
            if (hour > HOURS_IN_HALF_DAY) {
                // 下午时间，减去12
                return hour - HOURS_IN_HALF_DAY;
            } else {
                // 上午时间，0点转换为12点
                return hour == 0 ? HOURS_IN_HALF_DAY : hour;
            }
        }
@ -549,54 +434,35 @@ public class DateTimePicker extends FrameLayout {
        updateAmPmControl();
    }
    /**
     * 更新日期选择器的显示值
     * 生成一周内的日期显示字符串
     */
    private void updateDateControl() {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(mDate.getTimeInMillis());
        // 计算起始日期（当前日期减去3天）
        cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
        mDateSpinner.setDisplayedValues(null);
        // 生成一周的日期显示值
        for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
            cal.add(Calendar.DAY_OF_YEAR, 1);
            // 格式化日期为"MM.dd EEEE"（月.日 星期几）
            mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
        }
        mDateSpinner.setDisplayedValues(mDateDisplayValues);
-        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2); // 默认选择当前日期
+        mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
        mDateSpinner.invalidate();
    }
    /**
     * 更新AM/PM选择器的显示
     */
    private void updateAmPmControl() {
        if (mIs24HourView) {
            // 24小时制隐藏AM/PM选择器
            mAmPmSpinner.setVisibility(View.GONE);
        } else {
            // 12小时制设置AM/PM值并显示
            int index = mIsAm ? Calendar.AM : Calendar.PM;
            mAmPmSpinner.setValue(index);
            mAmPmSpinner.setVisibility(View.VISIBLE);
        }
    }
    /**
     * 更新小时选择器的范围
     */
    private void updateHourControl() {
        if (mIs24HourView) {
            // 24小时制范围：0-23
            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
        } else {
            // 12小时制范围：1-12
            mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
            mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
        }
@ -610,9 +476,6 @@ public class DateTimePicker extends FrameLayout {
        mOnDateTimeChangedListener = callback;
    }
    /**
     * 通知日期时间变化
     */
    private void onDateTimeChanged() {
        if (mOnDateTimeChangedListener != null) {
            mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
--- a/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
+++ b/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
@ -29,114 +29,59 @@ import android.content.DialogInterface.OnClickListener;
 import android.text.format.DateFormat;
 import android.text.format.DateUtils;
 /**
 * 日期时间选择对话框
 * 封装DateTimePicker组件，提供一个对话框界面让用户选择日期时间
 */
 public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
    /** 当前选择的日期 */
    private Calendar mDate = Calendar.getInstance();
    /** 是否为24小时制 */
    private boolean mIs24HourView;
    /** 日期时间设置监听器 */
    private OnDateTimeSetListener mOnDateTimeSetListener;
    /** 日期时间选择器组件 */
    private DateTimePicker mDateTimePicker;
    /**
     * 日期时间设置监听器接口
     * 用于监听用户选择日期时间后的确认事件
     */
    public interface OnDateTimeSetListener {
        /**
         * 当用户确认选择日期时间时调用
         * @param dialog 日期时间选择对话框实例
         * @param date 选择的日期时间（毫秒）
         */
        void OnDateTimeSet(AlertDialog dialog, long date);
    }
    /**
     * 创建一个日期时间选择对话框实例
     * @param context 上下文
     * @param date 初始日期时间（毫秒）
     */
    public DateTimePickerDialog(Context context, long date) {
        super(context);
        // 初始化日期时间选择器
        mDateTimePicker = new DateTimePicker(context);
        setView(mDateTimePicker);
        // 设置日期时间变化监听器
        mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
            public void onDateTimeChanged(DateTimePicker view, int year, int month,
                    int dayOfMonth, int hourOfDay, int minute) {
                // 更新当前日期时间
                mDate.set(Calendar.YEAR, year);
                mDate.set(Calendar.MONTH, month);
                mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
                mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
                mDate.set(Calendar.MINUTE, minute);
                // 更新对话框标题
                updateTitle(mDate.getTimeInMillis());
            }
        });
        // 设置初始日期时间（清除秒数）
        mDate.setTimeInMillis(date);
        mDate.set(Calendar.SECOND, 0);
        mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
        // 设置对话框按钮
        setButton(context.getString(R.string.datetime_dialog_ok), this);
        setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
        // 设置时间格式（24小时制/12小时制）
        set24HourView(DateFormat.is24HourFormat(this.getContext()));
        // 更新对话框标题
        updateTitle(mDate.getTimeInMillis());
    }
    /**
     * 设置是否使用24小时制
     * @param is24HourView true表示使用24小时制，false表示使用12小时制
     */
    public void set24HourView(boolean is24HourView) {
        mIs24HourView = is24HourView;
    }
    /**
     * 设置日期时间设置监听器
     * @param callBack 监听器实例
     */
    public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
        mOnDateTimeSetListener = callBack;
    }
    /**
     * 更新对话框标题，显示当前选择的日期时间
     * @param date 日期时间（毫秒）
     */
    private void updateTitle(long date) {
        int flag =
            DateUtils.FORMAT_SHOW_YEAR |
            DateUtils.FORMAT_SHOW_DATE |
            DateUtils.FORMAT_SHOW_TIME;
        // 根据时间格式设置标志
        flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
        // 格式化并设置标题
        setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
    }
    /**
     * 点击对话框按钮时调用
     * @param arg0 对话框实例
     * @param arg1 按钮索引
     */
    public void onClick(DialogInterface arg0, int arg1) {
        // 当点击确认按钮时，通知监听器日期时间已设置
        if (mOnDateTimeSetListener != null) {
            mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());
        }
--- a/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
+++ b/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
@ -27,34 +27,17 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
 import net.micode.notes.R;
 /**
 * 下拉菜单组件
 * 封装Android的PopupMenu功能，提供一个带有按钮和下拉菜单的组件
 */
 public class DropdownMenu {
    /** 下拉菜单的按钮 */
    private Button mButton;
    /** 弹出菜单实例 */
    private PopupMenu mPopupMenu;
    /** 菜单实例 */
    private Menu mMenu;
    /**
     * 创建一个下拉菜单实例
     * @param context 上下文
     * @param button 下拉菜单的按钮
     * @param menuId 菜单资源ID
     */
    public DropdownMenu(Context context, Button button, int menuId) {
        mButton = button;
        // 设置按钮背景为下拉图标
        mButton.setBackgroundResource(R.drawable.dropdown_icon);
        // 创建弹出菜单实例
        mPopupMenu = new PopupMenu(context, mButton);
        mMenu = mPopupMenu.getMenu();
        // 填充菜单内容
        mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
        // 设置按钮点击事件，显示弹出菜单
        mButton.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                mPopupMenu.show();
@ -62,29 +45,16 @@ public class DropdownMenu {
        });
    }
    /**
     * 设置菜单点击事件监听器
     * @param listener 菜单项点击事件监听器
     */
    public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
        if (mPopupMenu != null) {
            mPopupMenu.setOnMenuItemClickListener(listener);
        }
    }
    /**
     * 根据ID查找菜单项
     * @param id 菜单项ID
     * @return 菜单项实例，如果未找到返回null
     */
    public MenuItem findItem(int id) {
        return mMenu.findItem(id);
    }
    /**
     * 设置下拉菜单按钮的标题
     * @param title 标题文本
     */
    public void setTitle(CharSequence title) {
        mButton.setText(title);
    }
--- a/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
+++ b/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
@ -28,98 +28,50 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
-/**
+
 * 文件夹列表适配器
 * 用于在对话框中显示文件夹列表
 */
 /**
 * 文件夹列表适配器
 * 用于在列表中显示笔记文件夹的CursorAdapter
 */
 public class FoldersListAdapter extends CursorAdapter {
    /** 查询投影数组 */
    public static final String [] PROJECTION = {
-        NoteColumns.ID,      // 文件夹ID
+        NoteColumns.ID,
-        NoteColumns.SNIPPET  // 文件夹名称
+        NoteColumns.SNIPPET
    };
    /** 文件夹ID列索引 */
    public static final int ID_COLUMN   = 0;
    /** 文件夹名称列索引 */
    public static final int NAME_COLUMN = 1;
    /**
     * 创建一个文件夹列表适配器实例
     * @param context 上下文
     * @param c 包含文件夹数据的Cursor
     */
    public FoldersListAdapter(Context context, Cursor c) {
        super(context, c);
        // TODO Auto-generated constructor stub
    }
    /**
     * 创建一个新的文件夹列表项视图
     * @param context 上下文
     * @param cursor 包含文件夹数据的Cursor
     * @param parent 父视图组
     * @return 新创建的文件夹列表项视图
     */
    @Override
    public View newView(Context context, Cursor cursor, ViewGroup parent) {
        return new FolderListItem(context);
    }
    /**
     * 将文件夹数据绑定到列表项视图
     * @param view 列表项视图
     * @param context 上下文
     * @param cursor 包含文件夹数据的Cursor
     */
    @Override
    public void bindView(View view, Context context, Cursor cursor) {
        if (view instanceof FolderListItem) {
            // 如果是根文件夹，显示"移动到父文件夹"文本，否则显示文件夹名称
            String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
                    .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
            ((FolderListItem) view).bind(folderName);
        }
    }
    /**
     * 获取指定位置的文件夹名称
     * @param context 上下文
     * @param position 位置索引
     * @return 文件夹名称
     */
    public String getFolderName(Context context, int position) {
        Cursor cursor = (Cursor) getItem(position);
        // 如果是根文件夹，返回"移动到父文件夹"文本，否则返回文件夹名称
        return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
                .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
    }
    /**
     * 文件夹列表项视图
     */
    private class FolderListItem extends LinearLayout {
        /** 文件夹名称文本视图 */
        private TextView mName;
        /**
         * 创建一个文件夹列表项视图
         * @param context 上下文
         */
        public FolderListItem(Context context) {
            super(context);
            // 填充布局
            inflate(context, R.layout.folder_list_item, this);
            mName = (TextView) findViewById(R.id.tv_folder_name);
        }
        /**
         * 绑定文件夹名称到视图
         * @param name 文件夹名称
         */
        public void bind(String name) {
            mName.setText(name);
        }
--- a/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
@ -72,28 +72,18 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 /**
 * 笔记编辑活动
 * 负责处理笔记的创建、编辑和预览功能
 * 实现了笔记设置变化监听器和文本视图变化监听器接口
 */
 public class NoteEditActivity extends Activity implements OnClickListener,
        NoteSettingChangedListener, OnTextViewChangeListener {
    /**
     * 头部视图持有者类
     * 用于缓存头部视图的控件引用，提高性能
     */
    private class HeadViewHolder {
-        public TextView tvModified;       // 最后修改时间文本视图
+        public TextView tvModified;
-        public ImageView ivAlertIcon;     // 提醒图标
+
-        public TextView tvAlertDate;      // 提醒日期文本视图
+        public ImageView ivAlertIcon;
-        public ImageView ibSetBgColor;    // 设置背景颜色按钮
+
        public TextView tvAlertDate;
        public ImageView ibSetBgColor;
    }
    /**
     * 背景选择器按钮映射
     * 用于将背景选择按钮ID映射到对应的背景颜色常量
     */
    private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
    static {
        sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@ -103,10 +93,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
    }
    /**
     * 背景选择器选中状态映射
     * 用于将背景颜色常量映射到对应的选中状态图标ID
     */
    private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
    static {
        sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@ -116,10 +102,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
    }
    /**
     * 字体大小按钮映射
     * 用于将字体大小选择按钮ID映射到对应的字体大小常量
     */
    private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
    static {
        sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
@ -128,10 +110,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
    }
    /**
     * 字体选择器选中状态映射
     * 用于将字体大小常量映射到对应的选中状态图标ID
     */
    private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
    static {
        sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@ -140,47 +118,52 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
    }
-    private static final String TAG = "NoteEditActivity";  // 日志标签
+    private static final String TAG = "NoteEditActivity";
-    private HeadViewHolder mNoteHeaderHolder;        // 头部视图持有者
+    private HeadViewHolder mNoteHeaderHolder;
    private View mHeadViewPanel;                    // 头部视图面板
    private View mNoteBgColorSelector;              // 背景颜色选择器
    private View mFontSizeSelector;                 // 字体大小选择器
    private EditText mNoteEditor;                   // 笔记编辑器
    private View mNoteEditorPanel;                  // 笔记编辑器面板
    private WorkingNote mWorkingNote;               // 工作笔记对象
    private SharedPreferences mSharedPrefs;         // 共享偏好设置
    private int mFontSizeId;                        // 字体大小ID
-    private static final String PREFERENCE_FONT_SIZE = "pref_font_size";  // 字体大小偏好设置键
+    private View mHeadViewPanel;
    private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;  // 快捷图标标题最大长度
-    public static final String TAG_CHECKED = String.valueOf('\u221A');  // 已勾选标记
+    private View mNoteBgColorSelector;
    public static final String TAG_UNCHECKED = String.valueOf('\u25A1');  // 未勾选标记
-    private LinearLayout mEditTextList;             // 编辑文本列表（用于清单模式）
+    private View mFontSizeSelector;
-    private String mUserQuery;                      // 用户查询字符串
+
-    private Pattern mPattern;                       // 正则表达式模式（用于高亮查询结果）
+    private EditText mNoteEditor;
    private View mNoteEditorPanel;
    private WorkingNote mWorkingNote;
    private SharedPreferences mSharedPrefs;
    private int mFontSizeId;
    private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
    private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
    public static final String TAG_CHECKED = String.valueOf('\u221A');
    public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
    private LinearLayout mEditTextList;
    private String mUserQuery;
    private Pattern mPattern;
    /**
     * 创建活动时调用
     * @param savedInstanceState 保存的实例状态
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
-        this.setContentView(R.layout.note_edit);  // 设置布局
+        this.setContentView(R.layout.note_edit);
        // 如果没有保存的状态且无法初始化活动状态，则结束活动
        if (savedInstanceState == null && !initActivityState(getIntent())) {
            finish();
            return;
        }
-        initResources();  // 初始化资源
+        initResources();
    }
    /**
-     * 当前活动在内存不足时可能被杀死。一旦被杀死，当用户再次加载此活动时，我们应该恢复以前的状态
+     * Current activity may be killed when the memory is low. Once it is killed, for another time
     * user load this activity, we should restore the former state
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
@ -196,12 +179,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        }
    }
    /**
     * 初始化活动状态
     * 根据传入的意图设置工作笔记的状态
     * @param intent 传入的意图
     * @return 是否初始化成功
     */
    private boolean initActivityState(Intent intent) {
        /**
         * If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
@ -285,44 +262,27 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return true;
    }
    /**
     * 活动恢复时调用
     */
    @Override
    protected void onResume() {
        super.onResume();
-        initNoteScreen();  // 初始化笔记屏幕
+        initNoteScreen();
    }
    /**
     * 初始化笔记屏幕
     * 设置笔记编辑器的文本外观、内容和选择模式
     */
    private void initNoteScreen() {
        // 设置笔记编辑器的文本外观
        mNoteEditor.setTextAppearance(this, TextAppearanceResources
                .getTexAppearanceResource(mFontSizeId));
        // 根据笔记模式设置显示方式
        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
-            switchToListMode(mWorkingNote.getContent());  // 切换到清单模式
+            switchToListMode(mWorkingNote.getContent());
        } else {
            // 设置笔记内容并高亮查询结果
            mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
            // 将光标定位到文本末尾
            mNoteEditor.setSelection(mNoteEditor.getText().length());
        }
        // 隐藏所有背景选择的选中状态
        for (Integer id : sBgSelectorSelectionMap.keySet()) {
            findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
        }
        // 设置头部视图和编辑器面板的背景
        mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
        mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
        // 设置最后修改时间
        mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
                mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
                        | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
@ -332,13 +292,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
         * TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker
         * is not ready
         */
-        showAlertHeader();  // 显示提醒头部
+        showAlertHeader();
    }
    /**
     * 显示提醒头部
     * 根据笔记的提醒设置显示或隐藏提醒信息
     */
    private void showAlertHeader() {
        if (mWorkingNote.hasClockAlert()) {
            long time = System.currentTimeMillis();
@ -362,10 +318,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        initActivityState(intent);
    }
    /**
     * 保存活动状态
     * @param outState 保存状态的Bundle
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
@ -381,12 +333,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
    }
    /**
     * 分发触摸事件
     * 处理背景颜色选择器和字体大小选择器的点击外部关闭逻辑
     * @param ev 触摸事件
     * @return 是否消费了事件
     */
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
@ -403,12 +349,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return super.dispatchTouchEvent(ev);
    }
    /**
     * 检查触摸事件是否在视图范围内
     * @param view 视图对象
     * @param ev 触摸事件
     * @return 是否在范围内
     */
    private boolean inRangeOfView(View view, MotionEvent ev) {
        int []location = new int[2];
        view.getLocationOnScreen(location);
@ -423,10 +363,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return true;
    }
    /**
     * 初始化资源
     * 初始化所有UI控件和资源引用
     */
    private void initResources() {
        mHeadViewPanel = findViewById(R.id.note_title);
        mNoteHeaderHolder = new HeadViewHolder();
@ -438,25 +374,18 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
        mNoteEditorPanel = findViewById(R.id.sv_note_edit);
        mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
        // 为所有背景选择按钮设置点击监听器
        for (int id : sBgSelectorBtnsMap.keySet()) {
            ImageView iv = (ImageView) findViewById(id);
            iv.setOnClickListener(this);
        }
        mFontSizeSelector = findViewById(R.id.font_size_selector);
        // 为所有字体大小选择按钮设置点击监听器
        for (int id : sFontSizeBtnsMap.keySet()) {
            View view = findViewById(id);
            view.setOnClickListener(this);
        };
        // 初始化共享偏好设置和字体大小
        mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
        mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE);
        /**
         * HACKME: Fix bug of store the resource id in shared preference.
         * The id may larger than the length of resources, in this case,
@ -465,14 +394,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
            mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
        }
        mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
    }
    /**
     * 活动暂停时调用
     * 保存笔记并清除设置状态
     */
    @Override
    protected void onPause() {
        super.onPause();
@ -482,14 +406,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        clearSettingState();
    }
    /**
     * 更新小部件
     * 更新与当前笔记关联的小部件内容
     */
    private void updateWidget() {
        Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
        // 根据小部件类型设置对应的小部件提供器
        if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
            intent.setClass(this, NoteWidgetProvider_2x.class);
        } else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
@ -503,36 +421,26 @@ public class NoteEditActivity extends Activity implements OnClickListener,
            mWorkingNote.getWidgetId()
        });
-        sendBroadcast(intent);  // 发送广播更新小部件
+        sendBroadcast(intent);
        setResult(RESULT_OK, intent);
    }
    /**
     * 点击事件处理
     * 处理各种UI控件的点击事件
     * @param v 被点击的视图
     */
    public void onClick(View v) {
        int id = v.getId();
        if (id == R.id.btn_set_bg_color) {
            // 显示背景颜色选择器
            mNoteBgColorSelector.setVisibility(View.VISIBLE);
            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
-                    View.VISIBLE);
+                    -                    View.VISIBLE);
        } else if (sBgSelectorBtnsMap.containsKey(id)) {
            // 处理背景颜色选择
            findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                    View.GONE);
            mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
            mNoteBgColorSelector.setVisibility(View.GONE);
        } else if (sFontSizeBtnsMap.containsKey(id)) {
            // 处理字体大小选择
            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
            mFontSizeId = sFontSizeBtnsMap.get(id);
            mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
            findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
            // 根据当前模式更新字体大小
            if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
                getWorkingText();
                switchToListMode(mWorkingNote.getContent());
@ -544,9 +452,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        }
    }
    /**
     * 按下返回键时调用
     */
    @Override
    public void onBackPressed() {
        if(clearSettingState()) {
@ -557,11 +462,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        super.onBackPressed();
    }
    /**
     * 清除设置状态
     * 隐藏所有设置面板
     * @return 是否有设置面板被隐藏
     */
    private boolean clearSettingState() {
        if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
            mNoteBgColorSelector.setVisibility(View.GONE);
@ -573,10 +473,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return false;
    }
    /**
     * 背景颜色改变时调用
     * 实现NoteSettingChangedListener接口
     */
    public void onBackgroundColorChanged() {
        findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
                View.VISIBLE);
@ -584,11 +480,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
    }
    /**
     * 准备菜单时调用
     * @param menu 菜单对象
     * @return 是否准备成功
     */
    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        if (isFinishing()) {
@ -614,20 +505,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return true;
    }
    /**
     * 菜单项选择处理
     * 处理各种菜单按钮的点击事件
     * @param item 选择的菜单项
     * @return 是否处理了该事件
     */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_new_note:
-                createNewNote();  // 创建新笔记
+                createNewNote();
                break;
            case R.id.menu_delete:
                // 显示删除确认对话框
                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                builder.setTitle(getString(R.string.alert_title_delete));
                builder.setIcon(android.R.drawable.ic_dialog_alert);
@ -635,7 +519,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                builder.setPositiveButton(android.R.string.ok,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int which) {
-                                deleteCurrentNote();  // 删除当前笔记
+                                deleteCurrentNote();
                                finish();
                            }
                        });
@ -643,27 +527,25 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                builder.show();
                break;
            case R.id.menu_font_size:
                // 显示字体大小选择器
                mFontSizeSelector.setVisibility(View.VISIBLE);
                findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
                break;
            case R.id.menu_list_mode:
                // 切换笔记模式（普通模式/清单模式）
                mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
                        TextNote.MODE_CHECK_LIST : 0);
                break;
            case R.id.menu_share:
-                getWorkingText();  // 获取当前工作文本
+                getWorkingText();
-                sendTo(this, mWorkingNote.getContent());  // 分享笔记内容
+                sendTo(this, mWorkingNote.getContent());
                break;
            case R.id.menu_send_to_desktop:
-                sendToDesktop();  // 发送到桌面
+                sendToDesktop();
                break;
            case R.id.menu_alert:
-                setReminder();  // 设置提醒
+                setReminder();
                break;
            case R.id.menu_delete_remind:
-                mWorkingNote.setAlertDate(0, false);  // 删除提醒
+                mWorkingNote.setAlertDate(0, false);
                break;
            default:
                break;
@ -671,10 +553,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return true;
    }
    /**
     * 设置提醒
     * 显示日期时间选择器，设置笔记的提醒时间
     */
    private void setReminder() {
        DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
        d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
@ -686,10 +564,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
    }
    /**
-     * 分享笔记
+     * Share note to apps that support {@link Intent#ACTION_SEND} action
-     * 分享笔记内容到支持{@link Intent#ACTION_SEND}动作和{@text/plain}类型的应用
+     * and {@text/plain} type
     * @param context 上下文对象
     * @param info 要分享的内容
     */
    private void sendTo(Context context, String info) {
        Intent intent = new Intent(Intent.ACTION_SEND);
@ -698,15 +574,11 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        context.startActivity(intent);
    }
    /**
     * 创建新笔记
     * 保存当前笔记并创建一个新的笔记
     */
    private void createNewNote() {
-        // 首先保存当前编辑的笔记
+        // Firstly, save current editing notes
        saveNote();
-        // 为了安全起见，启动一个新的NoteEditActivity
+        // For safety, start a new NoteEditActivity
        finish();
        Intent intent = new Intent(this, NoteEditActivity.class);
        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
@ -714,10 +586,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        startActivity(intent);
    }
    /**
     * 删除当前笔记
     * 根据同步模式决定是直接删除还是移动到回收站
     */
    private void deleteCurrentNote() {
        if (mWorkingNote.existInDatabase()) {
            HashSet<Long> ids = new HashSet<Long>();
@ -728,12 +596,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                Log.d(TAG, "Wrong note id, should not happen");
            }
            if (!isSyncMode()) {
                // 非同步模式下直接删除
                if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) {
                    Log.e(TAG, "Delete Note error");
                }
            } else {
                // 同步模式下移动到回收站
                if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
                    Log.e(TAG, "Move notes to trash folder error, should not happens");
                }
@ -742,20 +608,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        mWorkingNote.markDeleted(true);
    }
    /**
     * 检查是否为同步模式
     * @return 是否为同步模式
     */
    private boolean isSyncMode() {
        return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
    }
    /**
     * 提醒时间改变时调用
     * 实现NoteSettingChangedListener接口
     * @param date 提醒时间
     * @param set 是否设置提醒
     */
    public void onClockAlertChanged(long date, boolean set) {
        /**
         * User could set clock to an unsaved note, so before setting the
@ -786,20 +642,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        }
    }
    /**
     * 小部件改变时调用
     * 实现NoteSettingChangedListener接口
     */
    public void onWidgetChanged() {
        updateWidget();
    }
    /**
     * 编辑文本删除时调用
     * 实现OnTextViewChangeListener接口
     * @param index 删除的索引
     * @param text 删除的文本
     */
    public void onEditTextDelete(int index, String text) {
        int childCount = mEditTextList.getChildCount();
        if (childCount == 1) {
@ -826,12 +672,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        edit.setSelection(length);
    }
    /**
     * 编辑文本回车时调用
     * 实现OnTextViewChangeListener接口
     * @param index 当前索引
     * @param text 文本内容
     */
    public void onEditTextEnter(int index, String text) {
        /**
         * Should not happen, check for debug
@ -851,43 +691,30 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        }
    }
    /**
     * 切换到清单模式
     * 将普通文本模式转换为清单模式
     * @param text 要转换的文本内容
     */
    private void switchToListMode(String text) {
-        mEditTextList.removeAllViews();  // 清空编辑文本列表
+        mEditTextList.removeAllViews();
-        String[] items = text.split("\n");  // 按行分割文本
+        String[] items = text.split("\n");
        int index = 0;
        for (String item : items) {
            if(!TextUtils.isEmpty(item)) {
-                mEditTextList.addView(getListItem(item, index));  // 添加列表项
+                mEditTextList.addView(getListItem(item, index));
                index++;
            }
        }
-        mEditTextList.addView(getListItem("", index));  // 添加最后一个空列表项
+        mEditTextList.addView(getListItem("", index));
-        mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();  // 设置焦点
+        mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
-        mNoteEditor.setVisibility(View.GONE);  // 隐藏普通编辑器
+        mNoteEditor.setVisibility(View.GONE);
-        mEditTextList.setVisibility(View.VISIBLE);  // 显示清单编辑器
+        mEditTextList.setVisibility(View.VISIBLE);
    }
    /**
     * 获取高亮查询结果
     * 对文本中的查询关键词进行高亮处理
     * @param fullText 完整文本
     * @param userQuery 用户查询字符串
     * @return 带有高亮效果的文本
     */
    private Spannable getHighlightQueryResult(String fullText, String userQuery) {
        SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
        if (!TextUtils.isEmpty(userQuery)) {
-            mPattern = Pattern.compile(userQuery);  // 编译正则表达式
+            mPattern = Pattern.compile(userQuery);
-            Matcher m = mPattern.matcher(fullText);  // 创建匹配器
+            Matcher m = mPattern.matcher(fullText);
            int start = 0;
            while (m.find(start)) {
                // 设置高亮背景色
                spannable.setSpan(
                        new BackgroundColorSpan(this.getResources().getColor(
                                R.color.user_query_highlight)), m.start(), m.end(),
@ -898,19 +725,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return spannable;
    }
    /**
     * 获取列表项视图
     * 创建并初始化清单模式下的单个列表项视图
     * @param item 列表项文本
     * @param index 列表项索引
     * @return 列表项视图
     */
    private View getListItem(String item, int index) {
        View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
        final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
        edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
        // 设置复选框的选中状态变化监听器
        CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
        cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
@ -922,7 +740,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
            }
        });
        // 处理已勾选和未勾选的标记
        if (item.startsWith(TAG_CHECKED)) {
            cb.setChecked(true);
            edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
@ -939,12 +756,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return view;
    }
    /**
     * 文本内容改变时调用
     * 实现OnTextViewChangeListener接口
     * @param index 当前索引
     * @param hasText 是否有文本内容
     */
    public void onTextChange(int index, boolean hasText) {
        if (index >= mEditTextList.getChildCount()) {
            Log.e(TAG, "Wrong index, should not happen");
@ -957,12 +768,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        }
    }
    /**
     * 清单模式改变时调用
     * 实现NoteSettingChangedListener接口
     * @param oldMode 旧模式
     * @param newMode 新模式
     */
    public void onCheckListModeChanged(int oldMode, int newMode) {
        if (newMode == TextNote.MODE_CHECK_LIST) {
            switchToListMode(mNoteEditor.getText().toString());
@ -977,11 +782,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        }
    }
    /**
     * 获取当前工作文本
     * 根据笔记模式获取当前编辑的文本内容
     * @return 是否有已勾选的项目
     */
    private boolean getWorkingText() {
        boolean hasChecked = false;
        if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
@ -1005,13 +805,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return hasChecked;
    }
    /**
     * 保存笔记
     * @return 是否保存成功
     */
    private boolean saveNote() {
-        getWorkingText();  // 获取当前工作文本
+        getWorkingText();
-        boolean saved = mWorkingNote.saveNote();  // 保存笔记到数据库
+        boolean saved = mWorkingNote.saveNote();
        if (saved) {
            /**
             * There are two modes from List view to edit view, open one note,
@ -1025,10 +821,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        return saved;
    }
    /**
     * 发送到桌面
     * 在桌面上创建当前笔记的快捷方式
     */
    private void sendToDesktop() {
        /**
         * Before send message to home, we should make sure that current
@ -1064,12 +856,6 @@ public class NoteEditActivity extends Activity implements OnClickListener,
        }
    }
    /**
     * 创建快捷图标标题
     * 处理快捷图标标题，移除标记并限制长度
     * @param content 笔记内容
     * @return 快捷图标标题
     */
    private String makeShortcutIconTitle(String content) {
        content = content.replace(TAG_CHECKED, "");
        content = content.replace(TAG_UNCHECKED, "");
@ -1077,19 +863,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
                SHORTCUT_ICON_TITLE_MAX_LEN) : content;
    }
    /**
     * 显示短时间提示
     * @param resId 提示文本资源ID
     */
    private void showToast(int resId) {
        showToast(resId, Toast.LENGTH_SHORT);
    }
    /**
     * 显示提示
     * @param resId 提示文本资源ID
     * @param duration 提示持续时间
     */
    private void showToast(int resId, int duration) {
        Toast.makeText(this, resId, duration).show();
    }
--- a/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
@ -37,31 +37,20 @@ import net.micode.notes.R;
 import java.util.HashMap;
 import java.util.Map;
 /**
 * 笔记编辑文本组件
 * 自定义的EditText组件，用于笔记编辑，支持链接检测和特殊的键盘事件处理
 */
 public class NoteEditText extends EditText {
    /** 日志标签 */
    private static final String TAG = "NoteEditText";
    /** 当前文本框的索引 */
    private int mIndex;
    /** 删除前的选择起始位置 */
    private int mSelectionStartBeforeDelete;
    /** 电话链接协议 */
    private static final String SCHEME_TEL = "tel:" ;
    /** HTTP链接协议 */
    private static final String SCHEME_HTTP = "http:" ;
    /** 电子邮件链接协议 */
    private static final String SCHEME_EMAIL = "mailto:" ;
    /** 链接协议与对应的操作资源ID映射 */
    private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
    static {
-        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);    // 电话链接操作文本
+        sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
-        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);   // 网页链接操作文本
+        sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
-        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email); // 电子邮件链接操作文本
+        sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
    }
    /**
@ -88,60 +77,33 @@ public class NoteEditText extends EditText {
    private OnTextViewChangeListener mOnTextViewChangeListener;
    /**
     * 创建一个笔记编辑文本组件实例
     * @param context 上下文
     */
    public NoteEditText(Context context) {
        super(context, null);
        mIndex = 0;
    }
    /**
     * 设置当前文本框的索引
     * @param index 索引值
     */
    public void setIndex(int index) {
        mIndex = index;
    }
    /**
     * 设置文本视图变化监听器
     * @param listener 监听器实例
     */
    public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
        mOnTextViewChangeListener = listener;
    }
    /**
     * 创建一个笔记编辑文本组件实例
     * @param context 上下文
     * @param attrs 属性集
     */
    public NoteEditText(Context context, AttributeSet attrs) {
        super(context, attrs, android.R.attr.editTextStyle);
    }
    /**
     * 创建一个笔记编辑文本组件实例
     * @param context 上下文
     * @param attrs 属性集
     * @param defStyle 默认样式
     */
    public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        // TODO Auto-generated constructor stub
    }
    /**
     * 处理触摸事件
     * @param event 触摸事件
     * @return 是否消费了事件
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
-                // 计算触摸位置在文本中的偏移量
+
                int x = (int) event.getX();
                int y = (int) event.getY();
                x -= getTotalPaddingLeft();
@ -152,7 +114,6 @@ public class NoteEditText extends EditText {
                Layout layout = getLayout();
                int line = layout.getLineForVertical(y);
                int off = layout.getOffsetForHorizontal(line, x);
                // 设置选择位置
                Selection.setSelection(getText(), off);
                break;
        }
@ -160,23 +121,15 @@ public class NoteEditText extends EditText {
        return super.onTouchEvent(event);
    }
    /**
     * 处理按键按下事件
     * @param keyCode 按键码
     * @param event 按键事件
     * @return 是否消费了事件
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_ENTER:
                // 如果设置了监听器，不拦截回车键
                if (mOnTextViewChangeListener != null) {
                    return false;
                }
                break;
            case KeyEvent.KEYCODE_DEL:
                // 记录删除前的选择起始位置
                mSelectionStartBeforeDelete = getSelectionStart();
                break;
            default:
@ -185,18 +138,11 @@ public class NoteEditText extends EditText {
        return super.onKeyDown(keyCode, event);
    }
    /**
     * 处理按键抬起事件
     * @param keyCode 按键码
     * @param event 按键事件
     * @return 是否消费了事件
     */
    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        switch(keyCode) {
            case KeyEvent.KEYCODE_DEL:
                if (mOnTextViewChangeListener != null) {
                    // 如果在文本框开头按下删除键且不是第一个文本框，触发删除事件
                    if (0 == mSelectionStartBeforeDelete && mIndex != 0) {
                        mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString());
                        return true;
@ -207,7 +153,6 @@ public class NoteEditText extends EditText {
                break;
            case KeyEvent.KEYCODE_ENTER:
                if (mOnTextViewChangeListener != null) {
                    // 处理回车键，将光标后的文本移到新的文本框
                    int selectionStart = getSelectionStart();
                    String text = getText().subSequence(selectionStart, length()).toString();
                    setText(getText().subSequence(0, selectionStart));
@ -222,16 +167,9 @@ public class NoteEditText extends EditText {
        return super.onKeyUp(keyCode, event);
    }
    /**
     * 处理焦点变化事件
     * @param focused 是否获得焦点
     * @param direction 焦点变化方向
     * @param previouslyFocusedRect 之前焦点所在的矩形
     */
    @Override
    protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
        if (mOnTextViewChangeListener != null) {
            // 当失去焦点且文本为空时，通知监听器文本已清空
            if (!focused && TextUtils.isEmpty(getText())) {
                mOnTextViewChangeListener.onTextChange(mIndex, false);
            } else {
@ -241,10 +179,6 @@ public class NoteEditText extends EditText {
        super.onFocusChanged(focused, direction, previouslyFocusedRect);
    }
    /**
     * 创建上下文菜单
     * @param menu 上下文菜单
     */
    @Override
    protected void onCreateContextMenu(ContextMenu menu) {
        if (getText() instanceof Spanned) {
@ -254,10 +188,8 @@ public class NoteEditText extends EditText {
            int min = Math.min(selStart, selEnd);
            int max = Math.max(selStart, selEnd);
            // 获取选中文本中的URL链接
            final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class);
            if (urls.length == 1) {
                // 根据链接协议获取对应的操作文本
                int defaultResId = 0;
                for(String schema: sSchemaActionResMap.keySet()) {
                    if(urls[0].getURL().indexOf(schema) >= 0) {
@ -267,14 +199,13 @@ public class NoteEditText extends EditText {
                }
                if (defaultResId == 0) {
-                    defaultResId = R.string.note_link_other; // 默认操作文本
+                    defaultResId = R.string.note_link_other;
                }
                // 添加菜单项并设置点击事件
                menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
                        new OnMenuItemClickListener() {
                            public boolean onMenuItemClick(MenuItem item) {
-                                // 处理链接点击事件
+                                // goto a new intent
                                urls[0].onClick(NoteEditText.this);
                                return true;
                            }
--- a/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
@ -25,101 +25,57 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.tool.DataUtils;
-/**
+
 * 笔记项数据类
 * 封装笔记列表项的数据信息
 */
 /**
 * 笔记列表项数据
 * 用于存储和管理笔记列表中每个项的数据
 */
 public class NoteItemData {
    /** 数据库查询投影数组 */
    static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,               // 笔记ID
+        NoteColumns.ID,
-        NoteColumns.ALERTED_DATE,     // 提醒日期
+        NoteColumns.ALERTED_DATE,
-        NoteColumns.BG_COLOR_ID,      // 背景颜色ID
+        NoteColumns.BG_COLOR_ID,
-        NoteColumns.CREATED_DATE,     // 创建日期
+        NoteColumns.CREATED_DATE,
-        NoteColumns.HAS_ATTACHMENT,   // 是否有附件
+        NoteColumns.HAS_ATTACHMENT,
-        NoteColumns.MODIFIED_DATE,    // 修改日期
+        NoteColumns.MODIFIED_DATE,
-        NoteColumns.NOTES_COUNT,      // 笔记数量
+        NoteColumns.NOTES_COUNT,
-        NoteColumns.PARENT_ID,        // 父文件夹ID
+        NoteColumns.PARENT_ID,
-        NoteColumns.SNIPPET,          // 笔记摘要
+        NoteColumns.SNIPPET,
-        NoteColumns.TYPE,             // 笔记类型
+        NoteColumns.TYPE,
-        NoteColumns.WIDGET_ID,        // 小部件ID
+        NoteColumns.WIDGET_ID,
-        NoteColumns.WIDGET_TYPE,      // 小部件类型
+        NoteColumns.WIDGET_TYPE,
    };
    /** 笔记ID列索引 */
    private static final int ID_COLUMN                    = 0;
    /** 提醒日期列索引 */
    private static final int ALERTED_DATE_COLUMN          = 1;
    /** 背景颜色ID列索引 */
    private static final int BG_COLOR_ID_COLUMN           = 2;
    /** 创建日期列索引 */
    private static final int CREATED_DATE_COLUMN          = 3;
    /** 是否有附件列索引 */
    private static final int HAS_ATTACHMENT_COLUMN        = 4;
    /** 修改日期列索引 */
    private static final int MODIFIED_DATE_COLUMN         = 5;
    /** 笔记数量列索引 */
    private static final int NOTES_COUNT_COLUMN           = 6;
    /** 父文件夹ID列索引 */
    private static final int PARENT_ID_COLUMN             = 7;
    /** 笔记摘要列索引 */
    private static final int SNIPPET_COLUMN               = 8;
    /** 笔记类型列索引 */
    private static final int TYPE_COLUMN                  = 9;
    /** 小部件ID列索引 */
    private static final int WIDGET_ID_COLUMN             = 10;
    /** 小部件类型列索引 */
    private static final int WIDGET_TYPE_COLUMN           = 11;
    /** 笔记ID */
    private long mId;
    /** 提醒日期 */
    private long mAlertDate;
    /** 背景颜色ID */
    private int mBgColorId;
    /** 创建日期 */
    private long mCreatedDate;
    /** 是否有附件 */
    private boolean mHasAttachment;
    /** 修改日期 */
    private long mModifiedDate;
    /** 笔记数量 */
    private int mNotesCount;
    /** 父文件夹ID */
    private long mParentId;
    /** 笔记摘要 */
    private String mSnippet;
    /** 笔记类型 */
    private int mType;
    /** 小部件ID */
    private int mWidgetId;
    /** 小部件类型 */
    private int mWidgetType;
    /** 联系人姓名（用于通话记录） */
    private String mName;
    /** 电话号码（用于通话记录） */
    private String mPhoneNumber;
    /** 是否为最后一项 */
    private boolean mIsLastItem;
    /** 是否为第一项 */
    private boolean mIsFirstItem;
    /** 是否只有一项 */
    private boolean mIsOnlyOneItem;
    /** 是否是文件夹后的唯一笔记 */
    private boolean mIsOneNoteFollowingFolder;
    /** 是否是文件夹后的多个笔记 */
    private boolean mIsMultiNotesFollowingFolder;
    /**
     * 创建一个笔记列表项数据实例
     * @param context 上下文
     * @param cursor 包含笔记数据的Cursor
     */
    public NoteItemData(Context context, Cursor cursor) {
        mId = cursor.getLong(ID_COLUMN);
        mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
@ -130,7 +86,6 @@ public class NoteItemData {
        mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
        mParentId = cursor.getLong(PARENT_ID_COLUMN);
        mSnippet = cursor.getString(SNIPPET_COLUMN);
        // 移除复选框标签
        mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
                NoteEditActivity.TAG_UNCHECKED, "");
        mType = cursor.getInt(TYPE_COLUMN);
@ -138,7 +93,6 @@ public class NoteItemData {
        mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
        mPhoneNumber = "";
        // 如果是通话记录文件夹中的笔记，获取电话号码和联系人姓名
        if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
            mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
            if (!TextUtils.isEmpty(mPhoneNumber)) {
@ -152,14 +106,9 @@ public class NoteItemData {
        if (mName == null) {
            mName = "";
        }
        // 检查笔记在列表中的位置
        checkPostion(cursor);
    }
    /**
     * 检查笔记在列表中的位置
     * @param cursor 包含笔记数据的Cursor
     */
    private void checkPostion(Cursor cursor) {
        mIsLastItem = cursor.isLast() ? true : false;
        mIsFirstItem = cursor.isFirst() ? true : false;
@ -167,20 +116,17 @@ public class NoteItemData {
        mIsMultiNotesFollowingFolder = false;
        mIsOneNoteFollowingFolder = false;
        // 如果是笔记类型且不是第一项，检查前一项是否为文件夹
        if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
            int position = cursor.getPosition();
            if (cursor.moveToPrevious()) {
                if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
                        || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
                    // 检查是否有多个笔记跟随在文件夹后面
                    if (cursor.getCount() > (position + 1)) {
                        mIsMultiNotesFollowingFolder = true;
                    } else {
                        mIsOneNoteFollowingFolder = true;
                    }
                }
                // 恢复Cursor位置
                if (!cursor.moveToNext()) {
                    throw new IllegalStateException("cursor move to previous but can't move back");
                }
@ -188,179 +134,90 @@ public class NoteItemData {
        }
    }
    /**
     * 是否是文件夹后的唯一笔记
     * @return true表示是文件夹后的唯一笔记，false表示不是
     */
    public boolean isOneFollowingFolder() {
        return mIsOneNoteFollowingFolder;
    }
    /**
     * 是否是文件夹后的多个笔记
     * @return true表示是文件夹后的多个笔记，false表示不是
     */
    public boolean isMultiFollowingFolder() {
        return mIsMultiNotesFollowingFolder;
    }
    /**
     * 是否为最后一项
     * @return true表示是最后一项，false表示不是
     */
    public boolean isLast() {
        return mIsLastItem;
    }
    /**
     * 获取联系人姓名（用于通话记录）
     * @return 联系人姓名
     */
    public String getCallName() {
        return mName;
    }
    /**
     * 是否为第一项
     * @return true表示是第一项，false表示不是
     */
    public boolean isFirst() {
        return mIsFirstItem;
    }
    /**
     * 是否只有一项
     * @return true表示只有一项，false表示不是
     */
    public boolean isSingle() {
        return mIsOnlyOneItem;
    }
    /**
     * 获取笔记ID
     * @return 笔记ID
     */
    public long getId() {
        return mId;
    }
    /**
     * 获取提醒日期
     * @return 提醒日期
     */
    public long getAlertDate() {
        return mAlertDate;
    }
    /**
     * 获取创建日期
     * @return 创建日期
     */
    public long getCreatedDate() {
        return mCreatedDate;
    }
    /**
     * 是否有附件
     * @return true表示有附件，false表示没有
     */
    public boolean hasAttachment() {
        return mHasAttachment;
    }
    /**
     * 获取修改日期
     * @return 修改日期
     */
    public long getModifiedDate() {
        return mModifiedDate;
    }
    /**
     * 获取背景颜色ID
     * @return 背景颜色ID
     */
    public int getBgColorId() {
        return mBgColorId;
    }
    /**
     * 获取父文件夹ID
     * @return 父文件夹ID
     */
    public long getParentId() {
        return mParentId;
    }
    /**
     * 获取笔记数量
     * @return 笔记数量
     */
    public int getNotesCount() {
        return mNotesCount;
    }
    /**
     * 获取文件夹ID
     * @return 文件夹ID
     */
    public long getFolderId () {
        return mParentId;
    }
    /**
     * 获取笔记类型
     * @return 笔记类型
     */
    public int getType() {
        return mType;
    }
    /**
     * 获取小部件类型
     * @return 小部件类型
     */
    public int getWidgetType() {
        return mWidgetType;
    }
    /**
     * 获取小部件ID
     * @return 小部件ID
     */
    public int getWidgetId() {
        return mWidgetId;
    }
    /**
     * 获取笔记摘要
     * @return 笔记摘要
     */
    public String getSnippet() {
        return mSnippet;
    }
    /**
     * 是否有提醒
     * @return true表示有提醒，false表示没有
     */
    public boolean hasAlert() {
        return (mAlertDate > 0);
    }
    /**
     * 是否为通话记录
     * @return true表示是通话记录，false表示不是
     */
    public boolean isCallRecord() {
        return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
    }
    /**
     * 从Cursor中获取笔记类型
     * @param cursor 包含笔记数据的Cursor
     * @return 笔记类型
     */
    public static int getNoteType(Cursor cursor) {
        return cursor.getInt(TYPE_COLUMN);
    }
--- a/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
@ -78,90 +78,85 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.HashSet;
 /**
 * 笔记列表活动 - 负责显示和管理笔记列表
 * 提供笔记的创建、编辑、删除、移动等功能
 * 支持文件夹管理和多选操作模式
 */
 public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
-    // 异步查询处理的标记常量
+    private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
-    private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0; // 查询笔记列表的标记
+
-    private static final int FOLDER_LIST_QUERY_TOKEN      = 1; // 查询文件夹列表的标记
+    private static final int FOLDER_LIST_QUERY_TOKEN      = 1;
    private static final int MENU_FOLDER_DELETE = 0;
-    // 文件夹上下文菜单的菜单项ID
+    private static final int MENU_FOLDER_VIEW = 1;
-    private static final int MENU_FOLDER_DELETE = 0;         // 删除文件夹
+
-    private static final int MENU_FOLDER_VIEW = 1;           // 查看文件夹
+    private static final int MENU_FOLDER_CHANGE_NAME = 2;
    private static final int MENU_FOLDER_CHANGE_NAME = 2;    // 修改文件夹名称
    // 用于存储应用介绍是否已添加的偏好设置键
    private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
    /**
     * 列表所处的编辑状态：
     * NOTE_LIST 根目录；SUB_FOLDER 子文件夹；CALL_RECORD_FOLDER 通话记录专用文件夹。
     */
    private enum ListEditState {
-        NOTE_LIST,            // 笔记列表状态
+        NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
        SUB_FOLDER,           // 子文件夹状态
        CALL_RECORD_FOLDER    // 通话记录文件夹状态
    };
-    // 成员变量
+    private ListEditState mState;
-    private ListEditState mState;                           // 当前列表编辑状态
+
-    private BackgroundQueryHandler mBackgroundQueryHandler; // 异步查询处理器
+    private BackgroundQueryHandler mBackgroundQueryHandler;
-    private NotesListAdapter mNotesListAdapter;             // 笔记列表适配器
+
-    private ListView mNotesListView;                        // 笔记列表视图
+    private NotesListAdapter mNotesListAdapter;
-    private Button mAddNewNote;                             // 新建笔记按钮
+
-    private boolean mDispatch;                              // 是否分发触摸事件给列表视图
+    private ListView mNotesListView;
-    private int mOriginY;                                   // 原始触摸Y坐标
+
-    private int mDispatchY;                                 // 分发触摸Y坐标
+    private Button mAddNewNote;
-    private TextView mTitleBar;                             // 标题栏
+
-    private long mCurrentFolderId;                          // 当前文件夹ID
+    private boolean mDispatch;
-    private ContentResolver mContentResolver;               // 内容解析器
+
-    private ModeCallback mModeCallBack;                     // 多选模式回调
+    private int mOriginY;
-
+
-    private static final String TAG = "NotesListActivity";  // 日志标签
+    private int mDispatchY;
-    public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;// 笔记列表滚动速率
+
-
+    private TextView mTitleBar;
-    private NoteItemData mFocusNoteDataItem;                // 当前焦点的笔记数据项
+
-
+    private long mCurrentFolderId;
-    // 查询条件常量
+
-    private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?"; // 普通文件夹查询条件
+    private ContentResolver mContentResolver;
    private ModeCallback mModeCallBack;
    private static final String TAG = "NotesListActivity";
    public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
    private NoteItemData mFocusNoteDataItem;
    private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
    private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"
            + Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
-            + NoteColumns.NOTES_COUNT + ">0)"; // 根文件夹查询条件（显示非系统文件夹和非空通话记录文件夹）
+            + NoteColumns.NOTES_COUNT + ">0)";
-    // 请求码常量
+    private final static int REQUEST_CODE_OPEN_NODE = 102;
-    private final static int REQUEST_CODE_OPEN_NODE = 102; // 打开笔记的请求码
+    private final static int REQUEST_CODE_NEW_NODE  = 103;
    private final static int REQUEST_CODE_NEW_NODE  = 103; // 新建笔记的请求码
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
-        setContentView(R.layout.note_list); // 设置布局
+        setContentView(R.layout.note_list);
-        initResources(); // 初始化资源
+        initResources();
-        // 首次进入时插入“介绍”笔记
+        /**
-        setAppInfoFromRawRes(); // 设置应用信息（首次使用时添加介绍笔记）
+         * Insert an introduction when user firstly use this application
         */
        setAppInfoFromRawRes();
    }
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        // 处理从NoteEditActivity返回的结果
        if (resultCode == RESULT_OK
                && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
            // 如果是打开或新建笔记的请求返回成功，刷新列表
            mNotesListAdapter.changeCursor(null);
        } else {
            super.onActivityResult(requestCode, resultCode, data);
        }
    }
 /**
     * 从原始资源文件中设置应用介绍信息
     * 当用户首次使用应用时，添加介绍笔记
     */
    private void setAppInfoFromRawRes() {
        SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
        if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
@ -208,20 +203,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }
    }
    /**
     * 当活动开始时调用
     * 启动异步查询笔记列表
     */
    @Override
    protected void onStart() {
        super.onStart();
        startAsyncNotesListQuery();
    }
 /**
     * 初始化资源
     * 设置内容解析器、异步查询处理器、列表适配器等
     */
    private void initResources() {
        mContentResolver = this.getContentResolver();
        mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
@ -244,19 +231,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        mModeCallBack = new ModeCallback();
    }
 /**
     * 多选模式回调类 - 处理笔记的多选操作
     * 实现了多选模式下的菜单创建、选择状态变化等功能
     */
    private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
        private DropdownMenu mDropDownMenu;
        private ActionMode mActionMode;
        private MenuItem mMoveMenu;
        /**
         * 创建操作模式时调用
         * 设置多选模式下的菜单和视图
         */
        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
            getMenuInflater().inflate(R.menu.note_list_options, menu);
            menu.findItem(R.id.delete).setOnMenuItemClickListener(this);
@ -290,10 +269,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
            return true;
        }
        /**
         * 更新菜单状态
         * 根据选择的笔记数量更新下拉菜单标题和全选状态
         */
        private void updateMenu() {
            int selectedCount = mNotesListAdapter.getSelectedCount();
            // Update dropdown menu
@ -321,37 +296,22 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
            return false;
        }
        /**
         * 销毁操作模式时调用
         * 恢复普通模式下的视图状态
         */
        public void onDestroyActionMode(ActionMode mode) {
            mNotesListAdapter.setChoiceMode(false);
            mNotesListView.setLongClickable(true);
            mAddNewNote.setVisibility(View.VISIBLE);
        }
        /**
         * 结束操作模式
         */
        public void finishActionMode() {
            mActionMode.finish();
        }
        /**
         * 当列表项的选择状态改变时调用
         * 更新适配器中的选择状态并刷新菜单
         */
        public void onItemCheckedStateChanged(ActionMode mode, int position, long id,
                boolean checked) {
            mNotesListAdapter.setCheckedItem(position, checked);
            updateMenu();
        }
        /**
         * 处理菜单项点击事件
         * 支持删除和移动操作
         */
        public boolean onMenuItemClick(MenuItem item) {
            if (mNotesListAdapter.getSelectedCount() == 0) {
                Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
@ -361,7 +321,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
            switch (item.getItemId()) {
                case R.id.delete:
                    // 显示删除确认对话框
                    AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
                    builder.setTitle(getString(R.string.alert_title_delete));
                    builder.setIcon(android.R.drawable.ic_dialog_alert);
@ -371,14 +330,13 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                                             new DialogInterface.OnClickListener() {
                                                 public void onClick(DialogInterface dialog,
                                                         int which) {
-                                                     batchDelete(); // 执行批量删除
+                                                     batchDelete();
                                                 }
                                             });
                    builder.setNegativeButton(android.R.string.cancel, null);
                    builder.show();
                    break;
                case R.id.move:
                    // 查询目标文件夹列表
                    startQueryDestinationFolders();
                    break;
                default:
@ -388,10 +346,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }
    }
 /**
     * 新建笔记按钮的触摸监听器
     * 处理特殊的触摸事件分发逻辑
     */
    private class NewNoteOnTouchListener implements OnTouchListener {
        public boolean onTouch(View v, MotionEvent event) {
@ -402,13 +356,22 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                    int newNoteViewHeight = mAddNewNote.getHeight();
                    int start = screenHeight - newNoteViewHeight;
                    int eventY = start + (int) event.getY();
-                    // 子文件夹状态需减去标题栏高度
+                    /**
                     * Minus TitleBar's height
                     */
                    if (mState == ListEditState.SUB_FOLDER) {
                        eventY -= mTitleBar.getHeight();
                        start -= mTitleBar.getHeight();
                    }
-                    // HACKME: 点击“新建”按钮透明区时，将事件派发给下方列表。
+                    /**
-                    // 透明区近似线性公式 y = -0.12x + 94（px），背景改动需同步更新该公式。
+                     * HACKME:When click the transparent part of "New Note" button, dispatch
                     * the event to the list view behind this button. The transparent part of
                     * "New Note" button could be expressed by formula y=-0.12x+94（Unit:pixel）
                     * and the line top of the button. The coordinate based on left of the "New
                     * Note" button. The 94 represents maximum height of the transparent part.
                     * Notice that, if the background of the button changes, the formula should
                     * also change. This is very bad, just for the UI designer's strong requirement.
                     */
                    if (event.getY() < (event.getX() * (-0.12) + 94)) {
                        View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
                                - mNotesListView.getFooterViewsCount());
@ -445,10 +408,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
    };
 /**
     * 开始异步查询笔记列表
     * 根据当前文件夹ID选择不同的查询条件
     */
    private void startAsyncNotesListQuery() {
        String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
                : NORMAL_SELECTION;
@ -458,27 +417,18 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
                }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
    }
 /**
     * 后台查询处理器 - 处理异步数据库查询
     */
    private final class BackgroundQueryHandler extends AsyncQueryHandler {
        public BackgroundQueryHandler(ContentResolver contentResolver) {
            super(contentResolver);
        }
        /**
         * 查询完成时调用
         * 根据不同的查询标记处理查询结果
         */
        @Override
        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
            switch (token) {
                case FOLDER_NOTE_LIST_QUERY_TOKEN:
                    // 查询笔记列表完成，更新适配器
                    mNotesListAdapter.changeCursor(cursor);
                    break;
                case FOLDER_LIST_QUERY_TOKEN:
                    // 查询文件夹列表完成，显示文件夹菜单
                    if (cursor != null && cursor.getCount() > 0) {
                        showFolderListMenu(cursor);
                    } else {
@ -491,10 +441,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }
    }
 /**
     * 显示文件夹列表菜单
     * 用于选择移动笔记的目标文件夹
     */
    private void showFolderListMenu(Cursor cursor) {
        AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
        builder.setTitle(R.string.menu_title_select_folder);
@ -516,10 +462,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        builder.show();
    }
 /**
     * 创建新笔记
     * 跳转到笔记编辑界面
     */
    private void createNewNote() {
        Intent intent = new Intent(this, NoteEditActivity.class);
        intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
@ -527,10 +469,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE);
    }
 /**
     * 批量删除笔记
     * 在同步模式下将笔记移动到回收站，非同步模式下直接删除
     */
    private void batchDelete() {
        new AsyncTask<Void, Void, HashSet<AppWidgetAttribute>>() {
            protected HashSet<AppWidgetAttribute> doInBackground(Void... unused) {
@ -568,10 +506,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }.execute();
    }
 /**
     * 删除文件夹
     * 在同步模式下将文件夹移动到回收站，非同步模式下直接删除
     */
    private void deleteFolder(long folderId) {
        if (folderId == Notes.ID_ROOT_FOLDER) {
            Log.e(TAG, "Wrong folder id, should not happen " + folderId);
@ -599,10 +533,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }
    }
 /**
     * 打开笔记
     * 跳转到笔记编辑界面查看/编辑笔记
     */
    private void openNode(NoteItemData data) {
        Intent intent = new Intent(this, NoteEditActivity.class);
        intent.setAction(Intent.ACTION_VIEW);
@ -610,10 +540,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE);
    }
 /**
     * 打开文件夹
     * 更新当前文件夹ID并重新查询笔记列表
     */
    private void openFolder(NoteItemData data) {
        mCurrentFolderId = data.getId();
        startAsyncNotesListQuery();
@ -631,10 +557,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        mTitleBar.setVisibility(View.VISIBLE);
    }
 /**
     * 处理点击事件
     * 当前只处理新建笔记按钮的点击
     */
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_new_note:
@ -645,9 +567,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }
    }
 /**
     * 显示软键盘
     */
    private void showSoftInput() {
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        if (inputMethodManager != null) {
@ -655,18 +574,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }
    }
 /**
     * 隐藏软键盘
     */
    private void hideSoftInput(View view) {
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
 /**
     * 显示创建或修改文件夹的对话框
     * @param create 是否为创建文件夹模式
     */
    private void showCreateOrModifyFolderDialog(final boolean create) {
        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
        View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
@ -752,10 +664,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        });
    }
    /**
     * 处理返回键按下事件
     * 根据当前状态返回到上一级菜单或退出应用
     */
    @Override
    public void onBackPressed() {
        switch (mState) {
@ -780,10 +688,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }
    }
 /**
     * 更新小部件
     * 根据小部件类型发送相应的广播更新
     */
    private void updateWidget(int appWidgetId, int appWidgetType) {
        Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
        if (appWidgetType == Notes.TYPE_WIDGET_2X) {
@ -803,10 +707,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        setResult(RESULT_OK, intent);
    }
 /**
     * 文件夹上下文菜单监听器
     * 创建文件夹的上下文菜单
     */
    private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
        public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
            if (mFocusNoteDataItem != null) {
@ -818,10 +718,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        }
    };
    /**
     * 上下文菜单关闭时调用
     * 清除列表视图的上下文菜单监听器
     */
    @Override
    public void onContextMenuClosed(Menu menu) {
        if (mNotesListView != null) {
@ -830,10 +726,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        super.onContextMenuClosed(menu);
    }
    /**
     * 处理上下文菜单项的选择
     * 支持查看、删除、重命名文件夹操作
     */
    @Override
    public boolean onContextItemSelected(MenuItem item) {
        if (mFocusNoteDataItem == null) {
@ -868,10 +760,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        return true;
    }
    /**
     * 准备选项菜单
     * 根据当前状态加载不同的菜单布局
     */
    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        menu.clear();
@ -890,10 +778,6 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
        return true;
    }
    /**
     * 处理选项菜单项的选择
     * 支持新建文件夹、导出文本、同步等操作
     */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
--- a/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
@ -30,41 +30,19 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
-/**
+
 * 笔记列表适配器。
 * <p>职责：为列表提供笔记/文件夹数据视图绑定，管理多选状态（批量删除/移动），并暴露选中项信息。</p>
 */
 /**
 * 笔记列表适配器
 * 继承自CursorAdapter，用于在列表视图中显示笔记数据
 * 支持多选模式和笔记项的选择状态管理
 */
 public class NotesListAdapter extends CursorAdapter {
    private static final String TAG = "NotesListAdapter";
    /** 上下文对象 */
    private Context mContext;
    /** 选中的索引映射（position -> 是否选中） */
    private HashMap<Integer, Boolean> mSelectedIndex;
    /** 笔记数量 */
    private int mNotesCount;
    /** 是否处于选择模式 */
    private boolean mChoiceMode;
    /**
     * 应用小部件属性类
     * 用于存储应用小部件的ID和类型信息
     */
    public static class AppWidgetAttribute {
        /** 小部件ID */
        public int widgetId;
        /** 小部件类型 */
        public int widgetType;
    };
    /**
     * 构造方法
     * @param context 应用上下文
     */
    public NotesListAdapter(Context context) {
        super(context, null);
        mSelectedIndex = new HashMap<Integer, Boolean>();
@ -72,25 +50,11 @@ public class NotesListAdapter extends CursorAdapter {
        mNotesCount = 0;
    }
    /**
     * 创建新的视图
     * @param context 应用上下文
     * @param cursor 数据库游标
     * @param parent 父视图组
     * @return 新创建的NotesListItem视图
     */
    @Override
    public View newView(Context context, Cursor cursor, ViewGroup parent) {
        return new NotesListItem(context);
    }
    /**
     * 绑定数据到视图
     * 将数据库游标中的数据绑定到NotesListItem视图上
     * @param view 要绑定的视图
     * @param context 应用上下文
     * @param cursor 数据库游标
     */
    @Override
    public void bindView(View view, Context context, Cursor cursor) {
        if (view instanceof NotesListItem) {
@ -100,42 +64,24 @@ public class NotesListAdapter extends CursorAdapter {
        }
    }
    /**
     * 设置指定位置的笔记项的选中状态
     * @param position 笔记项的位置
     * @param checked 选中状态，true为选中，false为未选中
     */
    public void setCheckedItem(final int position, final boolean checked) {
        mSelectedIndex.put(position, checked);
        notifyDataSetChanged();
    }
    /**
     * 检查是否处于选择模式
     * @return true表示处于选择模式，false表示非选择模式
     */
    public boolean isInChoiceMode() {
        return mChoiceMode;
    }
    /**
     * 设置选择模式
     * @param mode true为选择模式，false为非选择模式
     */
    public void setChoiceMode(boolean mode) {
-        mSelectedIndex.clear();  // 清除所有选中项
+        mSelectedIndex.clear();
        mChoiceMode = mode;
    }
    /**
     * 选择或取消选择所有笔记项
     * @param checked true为全选，false为取消全选
     */
    public void selectAll(boolean checked) {
        Cursor cursor = getCursor();
        for (int i = 0; i < getCount(); i++) {
            if (cursor.moveToPosition(i)) {
                // 只处理类型为笔记的项
                if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
                    setCheckedItem(i, checked);
                }
@ -143,10 +89,6 @@ public class NotesListAdapter extends CursorAdapter {
        }
    }
    /**
     * 获取所有选中项的ID
     * @return 包含所有选中项ID的HashSet
     */
    public HashSet<Long> getSelectedItemIds() {
        HashSet<Long> itemSet = new HashSet<Long>();
        for (Integer position : mSelectedIndex.keySet()) {
@ -163,10 +105,6 @@ public class NotesListAdapter extends CursorAdapter {
        return itemSet;
    }
    /**
     * 获取所有选中项的小部件属性
     * @return 包含所有选中项小部件属性的HashSet
     */
    public HashSet<AppWidgetAttribute> getSelectedWidget() {
        HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
        for (Integer position : mSelectedIndex.keySet()) {
@ -190,10 +128,6 @@ public class NotesListAdapter extends CursorAdapter {
        return itemSet;
    }
    /**
     * 获取选中项的数量
     * @return 选中项的数量
     */
    public int getSelectedCount() {
        Collection<Boolean> values = mSelectedIndex.values();
        if (null == values) {
@ -209,20 +143,11 @@ public class NotesListAdapter extends CursorAdapter {
        return count;
    }
    /**
     * 检查是否所有笔记项都被选中
     * @return true表示所有笔记项都被选中，false表示不是
     */
    public boolean isAllSelected() {
        int checkedCount = getSelectedCount();
        return (checkedCount != 0 && checkedCount == mNotesCount);
    }
    /**
     * 检查指定位置的笔记项是否被选中
     * @param position 笔记项的位置
     * @return true表示被选中，false表示未被选中
     */
    public boolean isSelectedItem(final int position) {
        if (null == mSelectedIndex.get(position)) {
            return false;
@ -233,25 +158,20 @@ public class NotesListAdapter extends CursorAdapter {
    @Override
    protected void onContentChanged() {
        super.onContentChanged();
-        calcNotesCount();  // 重新计算笔记总数
+        calcNotesCount();
    }
    @Override
    public void changeCursor(Cursor cursor) {
        super.changeCursor(cursor);
-        calcNotesCount();  // 重新计算笔记总数
+        calcNotesCount();
    }
    /**
     * 计算笔记总数
     * 遍历所有游标项，统计类型为笔记的项的数量
     */
    private void calcNotesCount() {
        mNotesCount = 0;
        for (int i = 0; i < getCount(); i++) {
            Cursor c = (Cursor) getItem(i);
            if (c != null) {
                // 只统计类型为笔记的项
                if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) {
                    mNotesCount++;
                }
--- a/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
@ -29,37 +29,18 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.tool.DataUtils;
 import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
-/**
+
 * 笔记列表项视图
 * 用于在列表中显示单个笔记项
 */
 /**
 * 笔记列表项视图
 * 用于在笔记列表中显示单个笔记项的自定义视图
 */
 public class NotesListItem extends LinearLayout {
    /** 提醒图标 */
    private ImageView mAlert;
    /** 笔记标题文本视图 */
    private TextView mTitle;
    /** 时间文本视图 */
    private TextView mTime;
    /** 联系人姓名文本视图（用于通话记录） */
    private TextView mCallName;
    /** 笔记项数据 */
    private NoteItemData mItemData;
    /** 复选框（用于选择模式） */
    private CheckBox mCheckBox;
    /**
     * 创建一个笔记列表项视图实例
     * @param context 上下文
     */
    public NotesListItem(Context context) {
        super(context);
        // 填充布局
        inflate(context, R.layout.note_item, this);
        // 获取视图组件
        mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
        mTitle = (TextView) findViewById(R.id.tv_title);
        mTime = (TextView) findViewById(R.id.tv_time);
@ -67,15 +48,7 @@ public class NotesListItem extends LinearLayout {
        mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
    }
    /**
     * 将笔记数据绑定到视图
     * @param context 上下文
     * @param data 笔记项数据
     * @param choiceMode 是否为选择模式
     * @param checked 是否被选中
     */
    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
        // 处理选择模式下的复选框显示
        if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
            mCheckBox.setVisibility(View.VISIBLE);
            mCheckBox.setChecked(checked);
@ -84,8 +57,6 @@ public class NotesListItem extends LinearLayout {
        }
        mItemData = data;
        // 处理通话记录文件夹
        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
            mCallName.setVisibility(View.GONE);
            mAlert.setVisibility(View.VISIBLE);
@ -93,9 +64,7 @@ public class NotesListItem extends LinearLayout {
            mTitle.setText(context.getString(R.string.call_record_folder_name)
                    + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
            mAlert.setImageResource(R.drawable.call_record);
-        } 
+        } else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
        // 处理通话记录笔记
        else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
            mCallName.setVisibility(View.VISIBLE);
            mCallName.setText(data.getCallName());
            mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
@ -106,20 +75,16 @@ public class NotesListItem extends LinearLayout {
            } else {
                mAlert.setVisibility(View.GONE);
            }
-        } 
+        } else {
        // 处理普通文件夹或笔记
        else {
            mCallName.setVisibility(View.GONE);
            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
            if (data.getType() == Notes.TYPE_FOLDER) {
                // 文件夹显示格式：名称 + 数量
                mTitle.setText(data.getSnippet()
                        + context.getString(R.string.format_folder_files_count,
                                data.getNotesCount()));
                mAlert.setVisibility(View.GONE);
            } else {
                // 笔记显示格式：摘要
                mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
                if (data.hasAlert()) {
                    mAlert.setImageResource(R.drawable.clock);
@ -129,23 +94,14 @@ public class NotesListItem extends LinearLayout {
                }
            }
        }
        // 设置修改时间
        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
        // 设置背景
        setBackground(data);
    }
    /**
     * 设置笔记项的背景
     * @param data 笔记项数据
     */
    private void setBackground(NoteItemData data) {
        int id = data.getBgColorId();
        if (data.getType() == Notes.TYPE_NOTE) {
            // 根据笔记在列表中的位置选择不同的背景
            if (data.isSingle() || data.isOneFollowingFolder()) {
                setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
            } else if (data.isLast()) {
@ -156,15 +112,10 @@ public class NotesListItem extends LinearLayout {
                setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
            }
        } else {
            // 文件夹使用固定背景
            setBackgroundResource(NoteItemBgResources.getFolderBgRes());
        }
    }
    /**
     * 获取笔记项数据
     * @return 笔记项数据
     */
    public NoteItemData getItemData() {
        return mItemData;
    }
--- a/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
@ -47,84 +47,56 @@ import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.remote.GTaskSyncService;
-/**
+
 * 笔记设置页面。
 * <p>职责：承载账户绑定/切换、GTask 同步开关、上次同步时间展示、背景随机开关等设置。</p>
 * <p>关键点：绑定账户时需清理本地 gtask 关联字段；同步过程中禁止修改账户；页面通过广播实时刷新同步状态。</p>
 */
 /**
 * 设置活动，用于管理同步账户、最后同步时间和背景颜色偏好
 */
 public class NotesPreferenceActivity extends PreferenceActivity {
    /** 偏好设置文件名 */
    public static final String PREFERENCE_NAME = "notes_preferences";
    /** 同步账户名存储键 */
    public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
    /** 最后同步时间存储键 */
    public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
    /** 设置背景颜色的偏好键 */
    public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
    /** 同步账户的偏好键 */
    private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
    /** 账户权限过滤键 */
    private static final String AUTHORITIES_FILTER_KEY = "authorities";
    /** 账户偏好分类 */
    private PreferenceCategory mAccountCategory;
    /** 同步状态广播接收器 */
    private GTaskReceiver mReceiver;
    /** 原始账户列表 */
    private Account[] mOriAccounts;
    /** 是否添加了新账户 */
    private boolean mHasAddedAccount;
    /**
     * 创建活动时调用，初始化布局、偏好设置和广播接收器
     * @param icicle 保存的实例状态
     */
    @Override
    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);
-        /* 使用应用图标作为导航 */
+        /* using the app icon for navigation */
        getActionBar().setDisplayHomeAsUpEnabled(true);
        // 从资源文件加载偏好设置
        addPreferencesFromResource(R.xml.preferences);
        // 获取账户偏好分类
        mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
        // 创建并注册同步状态广播接收器
        mReceiver = new GTaskReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
        registerReceiver(mReceiver, filter);
        mOriAccounts = null;
        // 加载设置头部布局
        View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
        getListView().addHeaderView(header, null, true);
    }
    /**
     * 活动恢复时调用，检查是否添加了新账户并刷新UI
     */
    @Override
    protected void onResume() {
        super.onResume();
-        // 若用户刚新增了 Google 账号，自动选中新账号为同步账号
+        // need to set sync account automatically if user has added a new
        // account
        if (mHasAddedAccount) {
            Account[] accounts = getGoogleAccounts();
            if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
                // 查找新增的账户
                for (Account accountNew : accounts) {
                    boolean found = false;
                    for (Account accountOld : mOriAccounts) {
@ -134,7 +106,6 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                        }
                    }
                    if (!found) {
                        // 设置新增账户为同步账户
                        setSyncAccount(accountNew.name);
                        break;
                    }
@ -142,48 +113,36 @@ public class NotesPreferenceActivity extends PreferenceActivity {
            }
        }
        // 刷新UI界面
        refreshUI();
    }
    /**
     * 活动销毁时调用，取消注册广播接收器
     */
    @Override
    protected void onDestroy() {
        // 取消注册同步状态广播接收器
        if (mReceiver != null) {
            unregisterReceiver(mReceiver);
        }
        super.onDestroy();
    }
    /**
     * 加载账户偏好设置，创建账户选择偏好项
     */
    private void loadAccountPreference() {
        // 清空账户偏好分类中的所有项
        mAccountCategory.removeAll();
        // 创建账户选择偏好项
        Preference accountPref = new Preference(this);
        final String defaultAccount = getSyncAccountName(this);
        accountPref.setTitle(getString(R.string.preferences_account_title));
        accountPref.setSummary(getString(R.string.preferences_account_summary));
        // 设置偏好项点击监听器
        accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
            public boolean onPreferenceClick(Preference preference) {
                // 只有当不同步时才能更改账户
                if (!GTaskSyncService.isSyncing()) {
                    if (TextUtils.isEmpty(defaultAccount)) {
-                        // 首次设置账户，显示账户选择对话框
+                        // the first time to set account
                        showSelectAccountAlertDialog();
                    } else {
-                        // 已绑定过账号，提示更换风险
+                        // if the account has already been set, we need to promp
                        // user about the risk
                        showChangeAccountConfirmAlertDialog();
                    }
                } else {
                    // 同步中不能更改账户，显示提示信息
                    Toast.makeText(NotesPreferenceActivity.this,
                            R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
                            .show();
@ -192,113 +151,85 @@ public class NotesPreferenceActivity extends PreferenceActivity {
            }
        });
        // 将账户偏好项添加到分类中
        mAccountCategory.addPreference(accountPref);
    }
    /**
     * 加载同步按钮和最后同步时间显示
     */
    private void loadSyncButton() {
        // 获取同步按钮和最后同步时间文本视图
        Button syncButton = (Button) findViewById(R.id.preference_sync_button);
        TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
-        // 根据同步状态配置按钮文案与行为
+        // set button state
        if (GTaskSyncService.isSyncing()) {
            // 同步中，按钮显示取消同步
            syncButton.setText(getString(R.string.preferences_button_sync_cancel));
            syncButton.setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    // 取消同步
                    GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
                }
            });
        } else {
            // 未同步，按钮显示立即同步
            syncButton.setText(getString(R.string.preferences_button_sync_immediately));
            syncButton.setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    // 开始同步
                    GTaskSyncService.startSync(NotesPreferenceActivity.this);
                }
            });
        }
        // 只有设置了同步账户，按钮才可用
        syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
-        // 展示最近同步时间或实时进度
+        // set last sync time
        if (GTaskSyncService.isSyncing()) {
            // 同步中，显示同步进度
            lastSyncTimeView.setText(GTaskSyncService.getProgressString());
            lastSyncTimeView.setVisibility(View.VISIBLE);
        } else {
            // 未同步，显示最后同步时间
            long lastSyncTime = getLastSyncTime(this);
            if (lastSyncTime != 0) {
                // 格式化并显示最后同步时间
                lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
                        DateFormat.format(getString(R.string.preferences_last_sync_time_format),
                                lastSyncTime)));
                lastSyncTimeView.setVisibility(View.VISIBLE);
            } else {
                // 从未同步过，隐藏时间显示
                lastSyncTimeView.setVisibility(View.GONE);
            }
        }
    }
    /**
     * 刷新UI界面，重新加载账户偏好和同步按钮
     */
    private void refreshUI() {
        loadAccountPreference();
        loadSyncButton();
    }
    /**
     * 显示选择账户的对话框，允许用户选择已有账户或添加新账户
     */
    private void showSelectAccountAlertDialog() {
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
        // 加载自定义标题视图
        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
        titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
        TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
        subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
        // 设置对话框标题和空的确定按钮
        dialogBuilder.setCustomTitle(titleView);
        dialogBuilder.setPositiveButton(null, null);
        // 获取所有Google账户
        Account[] accounts = getGoogleAccounts();
        String defAccount = getSyncAccountName(this);
        // 保存原始账户列表和添加账户标志
        mOriAccounts = accounts;
        mHasAddedAccount = false;
        if (accounts.length > 0) {
            // 创建账户列表项
            CharSequence[] items = new CharSequence[accounts.length];
            final CharSequence[] itemMapping = items;
            int checkedItem = -1;
            int index = 0;
            for (Account account : accounts) {
                // 标记当前默认账户
                if (TextUtils.equals(account.name, defAccount)) {
                    checkedItem = index;
                }
                items[index++] = account.name;
            }
            // 设置单选列表项和选择监听器
            dialogBuilder.setSingleChoiceItems(items, checkedItem,
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int which) {
                            // 设置选择的账户为同步账户
                            setSyncAccount(itemMapping[which].toString());
                            dialog.dismiss();
                            refreshUI();
@ -306,17 +237,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                    });
        }
        // 加载添加账户视图
        View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
        dialogBuilder.setView(addAccountView);
        // 显示对话框并设置添加账户点击监听器
        final AlertDialog dialog = dialogBuilder.show();
        addAccountView.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                // 标记已添加账户
                mHasAddedAccount = true;
                // 打开添加账户设置界面
                Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
                intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
                    "gmail-ls"
@ -327,13 +254,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        });
    }
    /**
     * 显示更改账户的确认对话框，提醒用户更改账户的风险
     */
    private void showChangeAccountConfirmAlertDialog() {
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
        // 加载自定义标题视图
        View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
        TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
        titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
@ -342,46 +265,31 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
        dialogBuilder.setCustomTitle(titleView);
        // 创建菜单项数组
        CharSequence[] menuItemArray = new CharSequence[] {
                getString(R.string.preferences_menu_change_account),
                getString(R.string.preferences_menu_remove_account),
                getString(R.string.preferences_menu_cancel)
        };
        // 设置菜单项点击监听器
        dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                if (which == 0) {
                    // 更改账户，显示账户选择对话框
                    showSelectAccountAlertDialog();
                } else if (which == 1) {
                    // 移除账户
                    removeSyncAccount();
                    refreshUI();
                }
            }
        });
        // 显示对话框
        dialogBuilder.show();
    }
    /**
     * 获取设备上所有的Google账户
     * @return Google账户数组
     */
    private Account[] getGoogleAccounts() {
        AccountManager accountManager = AccountManager.get(this);
        return accountManager.getAccountsByType("com.google");
    }
    /**
     * 设置同步账户，并清理相关的本地同步信息
     * @param account 要设置的账户名
     */
    private void setSyncAccount(String account) {
        // 只有当账户名不同时才更新
        if (!getSyncAccountName(this).equals(account)) {
            // 更新账户偏好设置
            SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = settings.edit();
            if (account != null) {
@ -391,10 +299,10 @@ public class NotesPreferenceActivity extends PreferenceActivity {
            }
            editor.commit();
-            // 清除最后同步时间
+            // clean up last sync time
            setLastSyncTime(this, 0);
-            // 在后台线程中清除本地Google Tasks相关信息
+            // clean up local gtask related info
            new Thread(new Runnable() {
                public void run() {
                    ContentValues values = new ContentValues();
@ -404,18 +312,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
                }
            }).start();
            // 显示设置成功提示
            Toast.makeText(NotesPreferenceActivity.this,
                    getString(R.string.preferences_toast_success_set_accout, account),
                    Toast.LENGTH_SHORT).show();
        }
    }
    /**
     * 移除同步账户，并清理相关的本地同步信息
     */
    private void removeSyncAccount() {
        // 清除账户偏好设置和最后同步时间
        SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = settings.edit();
        if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
@ -426,7 +329,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        }
        editor.commit();
-        // 在后台线程中清除本地Google Tasks相关信息
+        // clean up local gtask related info
        new Thread(new Runnable() {
            public void run() {
                ContentValues values = new ContentValues();
@ -437,22 +340,12 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        }).start();
    }
    /**
     * 获取当前同步账户名
     * @param context 上下文
     * @return 当前同步账户名，若无则返回空字符串
     */
    public static String getSyncAccountName(Context context) {
        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                Context.MODE_PRIVATE);
        return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
    }
    /**
     * 设置最后同步时间
     * @param context 上下文
     * @param time 最后同步时间的时间戳
     */
    public static void setLastSyncTime(Context context, long time) {
        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                Context.MODE_PRIVATE);
@ -461,32 +354,17 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        editor.commit();
    }
    /**
     * 获取最后同步时间
     * @param context 上下文
     * @return 最后同步时间的时间戳，若无则返回0
     */
    public static long getLastSyncTime(Context context) {
        SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
                Context.MODE_PRIVATE);
        return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
    }
    /**
     * 同步状态广播接收器，监听同步状态变化并更新UI
     */
    private class GTaskReceiver extends BroadcastReceiver {
        /**
         * 接收到广播时调用
         * @param context 上下文
         * @param intent 包含同步状态信息的意图
         */
        @Override
        public void onReceive(Context context, Intent intent) {
            // 刷新UI
            refreshUI();
            // 如果正在同步，更新同步状态文本
            if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
                TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
                syncStatus.setText(intent
@ -496,15 +374,9 @@ public class NotesPreferenceActivity extends PreferenceActivity {
        }
    }
    /**
     * 处理选项菜单的点击事件
     * @param item 被点击的菜单项
     * @return true表示事件已处理，false表示未处理
     */
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case android.R.id.home:
                // 点击返回按钮，返回笔记列表活动
                Intent intent = new Intent(this, NotesListActivity.class);
                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                startActivity(intent);
--- a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
@ -32,169 +32,101 @@ import net.micode.notes.tool.ResourceParser;
 import net.micode.notes.ui.NoteEditActivity;
 import net.micode.notes.ui.NotesListActivity;
 /**
 * 笔记小部件提供者抽象类
 * 提供笔记桌面小部件的基础功能
 */
 public abstract class NoteWidgetProvider extends AppWidgetProvider {
    /** 数据库查询投影，包含笔记ID、背景颜色ID和摘要 */
    public static final String [] PROJECTION = new String [] {
-        NoteColumns.ID,          // 笔记ID
+        NoteColumns.ID,
-        NoteColumns.BG_COLOR_ID, // 背景颜色ID
+        NoteColumns.BG_COLOR_ID,
-        NoteColumns.SNIPPET      // 笔记摘要
+        NoteColumns.SNIPPET
    };
    /** 投影列索引 - 笔记ID */
    public static final int COLUMN_ID           = 0;
    /** 投影列索引 - 背景颜色ID */
    public static final int COLUMN_BG_COLOR_ID  = 1;
    /** 投影列索引 - 笔记摘要 */
    public static final int COLUMN_SNIPPET      = 2;
    /** 日志标签 */
    private static final String TAG = "NoteWidgetProvider";
    /**
     * 当小部件被删除时调用，清除与该小部件关联的笔记信息
     * @param context 上下文
     * @param appWidgetIds 被删除的小部件ID数组
     */
    @Override
    public void onDeleted(Context context, int[] appWidgetIds) {
        // 创建要更新的内容值，将WIDGET_ID设置为无效值
        ContentValues values = new ContentValues();
        values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
        // 遍历所有被删除的小部件ID
        for (int i = 0; i < appWidgetIds.length; i++) {
            // 更新与小部件关联且不在回收站中的笔记，清除其WIDGET_ID
            context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
                    values,
-                    NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
+                    NoteColumns.WIDGET_ID + "=?",
-                    new String[] { String.valueOf(appWidgetIds[i]), String.valueOf(Notes.ID_TRASH_FOLER) });
+                    new String[] { String.valueOf(appWidgetIds[i])});
        }
    }
    /**
     * 获取与指定小部件关联的笔记信息
     * @param context 上下文
     * @param widgetId 小部件ID
     * @return 包含笔记信息的Cursor，若无则返回null
     */
    private Cursor getNoteWidgetInfo(Context context, int widgetId) {
        // 查询与指定小部件ID关联且不在回收站中的笔记
        return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
-                PROJECTION, // 查询的列
+                PROJECTION,
-                NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?", // 查询条件
+                NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
-                new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) }, // 参数值
+                new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
-                null); // 排序方式
+                null);
    }
    /**
     * 更新小部件内容的公共方法，默认非隐私模式
     * @param context 上下文
     * @param appWidgetManager 小部件管理器
     * @param appWidgetIds 要更新的小部件ID数组
     */
    protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        update(context, appWidgetManager, appWidgetIds, false);
    }
    /**
     * 更新小部件内容的私有方法，支持隐私模式
     * @param context 上下文
     * @param appWidgetManager 小部件管理器
     * @param appWidgetIds 要更新的小部件ID数组
     * @param privacyMode 是否为隐私模式
     */
    private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
            boolean privacyMode) {
        // 遍历所有小部件ID
        for (int i = 0; i < appWidgetIds.length; i++) {
            // 只处理有效的小部件ID
            if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
                // 默认背景颜色
                int bgId = ResourceParser.getDefaultBgId(context);
                String snippet = "";
                // 创建跳转到笔记编辑活动的意图
                Intent intent = new Intent(context, NoteEditActivity.class);
-                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); // 避免创建新的活动实例
+                intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
-                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]); // 传递小部件ID
+                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
-                intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType()); // 传递小部件类型
+                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)); // 传递笔记ID
+                    intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
-                    intent.setAction(Intent.ACTION_VIEW); // 设置操作为查看
+                    intent.setAction(Intent.ACTION_VIEW);
                } else {
                    // 无关联笔记，显示默认提示文本
                    snippet = context.getResources().getString(R.string.widget_havenot_content);
-                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT); // 设置操作为插入或编辑
+                    intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
                }
                // 关闭Cursor
                if (c != null) {
                    c.close();
                }
                // 创建RemoteViews以更新小部件UI
                RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
-                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId)); // 设置背景图片
+                rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
-                intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId); // 传递背景颜色ID
+                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);
                }
                // 设置小部件点击事件
                rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
                // 更新小部件
                appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
            }
        }
    }
    /**
     * 获取对应背景颜色ID的资源ID
     * @param bgId 背景颜色ID
     * @return 背景图片资源ID
     */
    protected abstract int getBgResourceId(int bgId);
    /**
     * 获取小部件布局的资源ID
     * @return 布局资源ID
     */
    protected abstract int getLayoutId();
    /**
     * 获取小部件类型
     * @return 小部件类型
     */
    protected abstract int getWidgetType();
 }
--- a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
@ -23,49 +23,23 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
-/**
+
 * 2x2笔记小部件提供者
 * 提供2x2尺寸的桌面笔记小部件
 */
 /**
 * 2x2 大小的笔记小部件提供者
 */
 public class NoteWidgetProvider_2x extends NoteWidgetProvider {
    /**
     * 当小部件需要更新时调用
     * @param context 上下文
     * @param appWidgetManager 小部件管理器
     * @param appWidgetIds 要更新的小部件ID数组
     */
    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        // 调用父类的update方法更新小部件
        super.update(context, appWidgetManager, appWidgetIds);
    }
    /**
     * 获取2x2小部件的布局资源ID
     * @return 布局资源ID
     */
    @Override
    protected int getLayoutId() {
        return R.layout.widget_2x;
    }
    /**
     * 获取2x2小部件对应背景颜色ID的资源ID
     * @param bgId 背景颜色ID
     * @return 背景图片资源ID
     */
    @Override
    protected int getBgResourceId(int bgId) {
        return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
    }
    /**
     * 获取2x2小部件的类型
     * @return 小部件类型常量
     */
    @Override
    protected int getWidgetType() {
        return Notes.TYPE_WIDGET_2X;
--- a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
@ -23,49 +23,22 @@ import net.micode.notes.R;
 import net.micode.notes.data.Notes;
 import net.micode.notes.tool.ResourceParser;
-/**
+
 * 4x4笔记小部件提供者
 * 提供4x4尺寸的桌面笔记小部件
 */
 /**
 * 4x4 大小的笔记小部件提供者
 */
 public class NoteWidgetProvider_4x extends NoteWidgetProvider {
    /**
     * 当小部件需要更新时调用
     * @param context 上下文
     * @param appWidgetManager 小部件管理器
     * @param appWidgetIds 要更新的小部件ID数组
     */
    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        // 调用父类的update方法更新小部件
        super.update(context, appWidgetManager, appWidgetIds);
    }
    /**
     * 获取4x4小部件的布局资源ID
     * @return 布局资源ID
     */
    @Override
    protected int getLayoutId() {
        return R.layout.widget_4x;
    }
    /**
     * 获取4x4小部件对应背景颜色ID的资源ID
     * @param bgId 背景颜色ID
     * @return 背景图片资源ID
     */
    @Override
    protected int getBgResourceId(int bgId) {
        return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
    }
    /**
     * 获取4x4小部件的类型
     * @return 小部件类型常量
     */
    @Override
    protected int getWidgetType() {
        return Notes.TYPE_WIDGET_4X;