From 37855e16eb7bd3bb3b8450048248bd9bed17843f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=91=A3=E6=98=A5=E9=98=B3?= <182569992@qq.com>
Date: Sat, 28 Dec 2024 20:18:00 +0800
Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E6=B3=A8=E9=87=8A=EF=BC=8C?=
 =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E9=94=99=E8=AF=AF=E6=8D=95=E8=8E=B72?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../src/net/micode/notes/data/Contact.java    |  27 +++-
 .../src/net/micode/notes/data/Notes.java      | 135 +++++++++---------
 .../notes/data/NotesDatabaseHelper.java       |  20 +++
 .../net/micode/notes/data/NotesProvider.java  |   1 +
 .../net/micode/notes/gtask/data/SqlNote.java  |  74 +++++++++-
 5 files changed, 176 insertions(+), 81 deletions(-)

diff --git a/src/Notes-master/src/net/micode/notes/data/Contact.java b/src/Notes-master/src/net/micode/notes/data/Contact.java
index 5fd3378..967d3e0 100644
--- a/src/Notes-master/src/net/micode/notes/data/Contact.java
+++ b/src/Notes-master/src/net/micode/notes/data/Contact.java
@@ -27,16 +27,28 @@ import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-public class Contact { //联系人
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.provider.ContactsContract;
+import android.telephony.PhoneNumberUtils;
+import android.util.Log;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+// Contact类用于通过电话号码获取联系人姓名，并且实现了一个简单的缓存机制
+public class Contact {
     // 定义最大缓存数量，可根据实际情况调整，这里假设最多缓存100个联系人信息
     private static final int MAX_CACHE_SIZE = 100;
     // 使用LinkedHashMap来实现缓存，它能保持插入顺序，方便后续按顺序清理较旧的缓存项
     private static LinkedHashMap<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 "
+    // 定义用于查询联系人的SQL选择语句，通过电话号码在联系人数据库中查找匹配的联系人
+    private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + ContactsContract.CommonDataKinds.Phone.NUMBER
+            + ",?) AND " + ContactsContract.Data.MIMETYPE + "='" + ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE + "'"
+            + " AND " + ContactsContract.Data.RAW_CONTACT_ID + " IN "
             + "(SELECT raw_contact_id "
             + " FROM phone_lookup"
             + " WHERE min_match = '+')";
@@ -69,9 +81,10 @@ public class Contact { //联系人
         // 根据传入的电话号码构建查询条件，替换特定的占位符等
         String selection = CALLER_ID_SELECTION.replace("+",
                 PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
-        Cursor cursor = context.getContentResolver().query(
-                Data.CONTENT_URI,
-                new String[]{Phone.DISPLAY_NAME},
+        ContentResolver contentResolver = context.getContentResolver();
+        Cursor cursor = contentResolver.query(
+                ContactsContract.Data.CONTENT_URI,
+                new String[]{ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME},
                 selection,
                 new String[]{phoneNumber},
                 null);
diff --git a/src/Notes-master/src/net/micode/notes/data/Notes.java b/src/Notes-master/src/net/micode/notes/data/Notes.java
index da15e51..6a91593 100644
--- a/src/Notes-master/src/net/micode/notes/data/Notes.java
+++ b/src/Notes-master/src/net/micode/notes/data/Notes.java
@@ -18,240 +18,241 @@ package net.micode.notes.data;
 
 import android.net.Uri;
 // 定义一个名为Notes的公共类，用于管理笔记相关的常量和接口
+// Notes类定义了与笔记应用相关的各种常量、接口和内部类，用于管理笔记、文件夹、数据等信息
 public class Notes {
-    // 内容提供者的权限名称，用于在应用内标识该内容提供者
+    // 内容提供者的权限名称，用于在应用内标识该内容提供者，其他组件通过此名称与对应的内容提供者进行交互
     public static final String AUTHORITY = "micode_notes";
-    // 日志标签，用于在日志输出中标识该类相关的日志信息
+    // 日志标签，用于在日志输出中标识该类相关的日志信息，方便开发者在调试时定位与该类相关的日志
     public static final String TAG = "Notes";
-    // 表示笔记类型的常量
+    // 表示笔记类型的常量，用于区分不同类型的记录，这里定义为普通笔记类型
     public static final int TYPE_NOTE = 0;
-    // 表示文件夹类型的常量
+    // 表示文件夹类型的常量，用于区分不同类型的记录，这里定义为文件夹类型
     public static final int TYPE_FOLDER = 1;
-    // 表示系统类型的常量
+    // 表示系统类型的常量，用于区分不同类型的记录，这里定义为系统相关类型
     public static final int TYPE_SYSTEM = 2;
 
     /**
      * 以下ID是系统文件夹的标识符
-     * {@link Notes#ID_ROOT_FOLDER } 是默认文件夹
-     * {@link Notes#ID_TEMPARAY_FOLDER } 用于存放不属于任何文件夹的笔记
-     * {@link Notes#ID_CALL_RECORD_FOLDER} 用于存储通话记录
+     * {@link Notes#ID_ROOT_FOLDER } 是默认文件夹，通常作为所有文件夹和笔记的根目录
+     * {@link Notes#ID_TEMPARAY_FOLDER } 用于存放不属于任何文件夹的笔记，是一种临时存放的机制
+     * {@link Notes#ID_CALL_RECORD_FOLDER} 用于存储通话记录，专门存放与通话记录相关的笔记
      */
-    // 根文件夹的ID
+    // 根文件夹的ID，作为整个文件夹结构的根节点
     public static final int ID_ROOT_FOLDER = 0;
-    // 临时文件夹的ID，用于存放不属于任何文件夹的笔记
+    // 临时文件夹的ID，用于存放不属于任何文件夹的笔记，方便对孤立笔记进行管理
     public static final int ID_TEMPARAY_FOLDER = -1;
-    // 通话记录文件夹的ID
+    // 通话记录文件夹的ID，用于标识存储通话记录的特定文件夹
     public static final int ID_CALL_RECORD_FOLDER = -2;
-    // 回收站文件夹的ID
+    // 回收站文件夹的ID，用于标识存放已删除笔记或文件夹的回收站
     public static final int ID_TRASH_FOLER = -3;
 
-    // 用于在Intent中传递提醒日期的额外字段名称
+    // 用于在Intent中传递提醒日期的额外字段名称，当通过Intent在不同组件间传递数据时，使用此名称来获取或设置提醒日期
     public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
-    // 用于在Intent中传递背景颜色ID的额外字段名称
+    // 用于在Intent中传递背景颜色ID的额外字段名称，通过此名称在Intent中传递笔记的背景颜色ID
     public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
-    // 用于在Intent中传递小部件ID的额外字段名称
+    // 用于在Intent中传递小部件ID的额外字段名称，借助此名称在Intent中携带小部件的ID信息
     public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
-    // 用于在Intent中传递小部件类型的额外字段名称
+    // 用于在Intent中传递小部件类型的额外字段名称，方便在不同组件间传递小部件的类型信息
     public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
-    // 用于在Intent中传递文件夹ID的额外字段名称
+    // 用于在Intent中传递文件夹ID的额外字段名称，通过此名称在Intent中传递文件夹的ID
     public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
-    // 用于在Intent中传递通话日期的额外字段名称
+    // 用于在Intent中传递通话日期的额外字段名称，当涉及通话记录相关的Intent传递时，使用此名称传递通话日期
     public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
 
-    // 无效的小部件类型
+    // 无效的小部件类型，用于表示小部件类型不合法或未定义的情况
     public static final int TYPE_WIDGET_INVALIDE = -1;
-    // 2x尺寸的小部件类型
+    // 2x尺寸的小部件类型，定义了一种常见的小部件尺寸类型
     public static final int TYPE_WIDGET_2X = 0;
-    // 4x尺寸的小部件类型
+    // 4x尺寸的小部件类型，定义了另一种常见的小部件尺寸类型
     public static final int TYPE_WIDGET_4X = 1;
 
-    // 数据常量的内部类，用于存储不同类型数据的相关常量
+    // 数据常量的内部类，用于存储不同类型数据的相关常量，方便对不同类型数据进行统一管理和引用
     public static class DataConstants {
-        // 文本笔记的内容类型
+        // 文本笔记的内容类型，用于标识文本笔记在数据存储和传输中的类型
         public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
-        // 通话笔记的内容类型
+        // 通话笔记的内容类型，用于标识通话笔记在数据存储和传输中的类型
         public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
     }
 
     /**
-     * 用于查询所有笔记和文件夹的Uri
+     * 用于查询所有笔记和文件夹的Uri，通过此Uri可以向内容提供者请求获取所有笔记和文件夹的相关数据
      */
     public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
 
     /**
-     * 用于查询数据的Uri
+     * 用于查询数据的Uri，通过此Uri可以向内容提供者请求获取与笔记相关的具体数据
      */
     public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
 
-    // 笔记列的接口，定义了与笔记相关的数据库列名
+    // 笔记列的接口，定义了与笔记相关的数据库列名，这些列名用于在数据库中存储和检索笔记的各种属性
     public interface NoteColumns {
         /**
-         * 行的唯一ID
+         * 行的唯一ID，用于唯一标识数据库表中的每一条记录，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String ID = "_id";
 
         /**
-         * 笔记或文件夹的父级ID
+         * 笔记或文件夹的父级ID，用于建立文件夹和笔记之间的父子关系，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String PARENT_ID = "parent_id";
 
         /**
-         * 笔记或文件夹的创建日期
+         * 笔记或文件夹的创建日期，记录笔记或文件夹创建的时间，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String CREATED_DATE = "created_date";
 
         /**
-         * 最新修改日期
+         * 最新修改日期，记录笔记或文件夹最后一次被修改的时间，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String MODIFIED_DATE = "modified_date";
 
         /**
-         * 提醒日期
+         * 提醒日期，用于设置笔记的提醒时间，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String ALERTED_DATE = "alert_date";
 
         /**
-         * 文件夹的名称或笔记的文本内容
+         * 文件夹的名称或笔记的文本内容，存储文件夹的名称或者笔记的简短文本内容，类型为文本型
          * <P> 类型: TEXT </P>
          */
         public static final String SNIPPET = "snippet";
 
         /**
-         * 笔记的小部件ID
+         * 笔记的小部件ID，用于关联笔记和对应的小部件，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String WIDGET_ID = "widget_id";
 
         /**
-         * 笔记的小部件类型
+         * 笔记的小部件类型，用于标识笔记所关联小部件的类型，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String WIDGET_TYPE = "widget_type";
 
         /**
-         * 笔记的背景颜色ID
+         * 笔记的背景颜色ID，用于设置笔记的背景颜色，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String BG_COLOR_ID = "bg_color_id";
 
         /**
-         * 对于文本笔记，它没有附件；对于多媒体笔记，它至少有一个附件
+         * 对于文本笔记，它没有附件；对于多媒体笔记，它至少有一个附件。此列用于标识笔记是否有附件，类型为整型
          * <P> 类型: INTEGER </P>
          */
         public static final String HAS_ATTACHMENT = "has_attachment";
 
         /**
-         * 文件夹中的笔记数量
+         * 文件夹中的笔记数量，记录文件夹内包含的笔记数量，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String NOTES_COUNT = "notes_count";
 
         /**
-         * 文件类型：文件夹或笔记
+         * 文件类型：文件夹或笔记，用于标识当前记录是文件夹还是笔记，类型为整型
          * <P> 类型: INTEGER </P>
          */
         public static final String TYPE = "type";
 
         /**
-         * 最后同步ID
+         * 最后同步ID，用于记录笔记或文件夹最后一次与外部数据源同步的标识，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String SYNC_ID = "sync_id";
 
         /**
-         * 表示是否本地修改的标志
+         * 表示是否本地修改的标志，用于标记笔记或文件夹是否在本地进行了修改，类型为整型
          * <P> 类型: INTEGER </P>
          */
         public static final String LOCAL_MODIFIED = "local_modified";
 
         /**
-         * 移动到临时文件夹之前的原始父级ID
+         * 移动到临时文件夹之前的原始父级ID，当笔记或文件夹被移动到临时文件夹时，记录其原始的父级ID，类型为整型
          * <P> 类型 : INTEGER </P>
          */
         public static final String ORIGIN_PARENT_ID = "origin_parent_id";
 
         /**
-         * gtask的ID
+         * gtask的ID，用于关联笔记和gtask（可能是某种外部任务管理系统），类型为文本型
          * <P> 类型 : TEXT </P>
          */
         public static final String GTASK_ID = "gtask_id";
 
         /**
-         * 版本号
+         * 版本号，用于记录笔记或文件夹数据的版本，可能用于数据更新和同步的版本控制，类型为长整型
          * <P> 类型 : INTEGER (long) </P>
          */
         public static final String VERSION = "version";
     }
 
-    // 数据列的接口，定义了与数据相关的数据库列名
+    // 数据列的接口，定义了与数据相关的数据库列名，这些列名用于在数据库中存储和检索与笔记相关的具体数据
     public interface DataColumns {
         /**
-         * 行的唯一ID
+         * 行的唯一ID，用于唯一标识数据库表中与数据相关的每一条记录，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String ID = "_id";
 
         /**
-         * 此行表示的项目的MIME类型
+         * 此行表示的项目的MIME类型，用于标识数据的类型，如文本、图片等，类型为文本型
          * <P> 类型: Text </P>
          */
         public static final String MIME_TYPE = "mime_type";
 
         /**
-         * 此数据所属笔记的引用ID
+         * 此数据所属笔记的引用ID，用于关联数据和对应的笔记，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String NOTE_ID = "note_id";
 
         /**
-         * 笔记或文件夹的创建日期
+         * 笔记或文件夹的创建日期，记录数据所关联的笔记或文件夹的创建时间，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String CREATED_DATE = "created_date";
 
         /**
-         * 最新修改日期
+         * 最新修改日期，记录数据所关联的笔记或文件夹的最后一次修改时间，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String MODIFIED_DATE = "modified_date";
 
         /**
-         * 数据的内容
+         * 数据的内容，存储具体的数据内容，类型为文本型
          * <P> 类型: TEXT </P>
          */
         public static final String CONTENT = "content";
 
         /**
-         * 通用数据列，含义与{@link #MIMETYPE}相关，用于整数数据类型
+         * 通用数据列，含义与{@link #MIMETYPE}相关，用于整数数据类型，其具体含义根据MIME类型而定
          * <P> 类型: INTEGER </P>
          */
         public static final String DATA1 = "data1";
 
         /**
-         * 通用数据列，含义与{@link #MIMETYPE}相关，用于整数数据类型
+         * 通用数据列，含义与{@link #MIMETYPE}相关，用于整数数据类型，其具体含义根据MIME类型而定
          * <P> 类型: INTEGER </P>
          */
         public static final String DATA2 = "data2";
 
         /**
-         * 通用数据列，含义与{@link #MIMETYPE}相关，用于文本数据类型
+         * 通用数据列，含义与{@link #MIMETYPE}相关，用于文本数据类型，其具体含义根据MIME类型而定
          * <P> 类型: TEXT </P>
          */
         public static final String DATA3 = "data3";
 
         /**
-         * 通用数据列，含义与{@link #MIMETYPE}相关，用于文本数据类型
+         * 通用数据列，含义与{@link #MIMETYPE}相关，用于文本数据类型，其具体含义根据MIME类型而定
          * <P> 类型: TEXT </P>
          */
         public static final String DATA4 = "data4";
 
         /**
-         * 通用数据列，含义与{@link #MIMETYPE}相关，用于文本数据类型
+         * 通用数据列，含义与{@link #MIMETYPE}相关，用于文本数据类型，其具体含义根据MIME类型而定
          * <P> 类型: TEXT </P>
          */
         public static final String DATA5 = "data5";
@@ -265,42 +266,40 @@ public class Notes {
          */
         public static final String MODE = DATA1;
 
-        // 复选框列表模式的模式值
+        // 复选框列表模式的模式值，当MODE的值为1时，表示文本处于复选框列表模式
         public static final int MODE_CHECK_LIST = 1;
 
-        // 文本笔记的内容类型（目录类型）
+        // 文本笔记的内容类型（目录类型），用于标识文本笔记在数据存储和传输中的目录类型
         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
 
-        // 文本笔记的内容类型（项目类型）
+        // 文本笔记的内容类型（项目类型），用于标识文本笔记在数据存储和传输中的项目类型
         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
 
-        // 文本笔记的内容Uri
+        // 文本笔记的内容Uri，通过此Uri可以向内容提供者请求获取文本笔记的相关数据
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
     }
 
     // 通话笔记的静态内部类，实现了DataColumns接口，定义了通话笔记相关的常量
     public static final class CallNote implements DataColumns {
         /**
-         * 此通话记录的通话日期
+         * 此通话记录的通话日期，记录通话发生的时间，类型为长整型
          * <P> 类型: INTEGER (long) </P>
          */
         public static final String CALL_DATE = DATA1;
 
         /**
-         * 此通话记录的电话号码
+         * 此通话记录的电话号码，记录通话的对方电话号码，类型为文本型
          * <P> 类型: TEXT </P>
          */
         public static final String PHONE_NUMBER = DATA3;
 
-        // 通话笔记的内容类型（目录类型）
+        // 通话笔记的内容类型（目录类型），用于标识通话笔记在数据存储和传输中的目录类型
         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
 
-        // 通话笔记的内容类型（项目类型）
+        // 通话笔记的内容类型（项目类型），用于标识通话笔记在数据存储和传输中的项目类型
         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
 
-        // 通话笔记的内容Uri
+        // 通话笔记的内容Uri，通过此Uri可以向内容提供者请求获取通话笔记的相关数据
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
     }
-}
-//这段 Notes 类代码整体构建了一个较为完善的笔记相关数据管理的基础框架，涵盖了从基本的类型定义、文件夹标识、用于数据传递
-// 的键名、数据操作的 Uri 到具体的笔记（文本笔记和通话记录笔记）的数据结构和字段定义等多个方面。
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java b/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
index 13dee9c..605ad13 100644
--- a/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
+++ b/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
@@ -67,6 +67,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
                     NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
                     ")";
+    // 创建笔记表，定义了笔记的各种属性列，如ID、父ID、提醒日期、背景颜色ID等，设置了默认值并指定ID为主键
 
     // 创建数据表的SQL语句
     private static final String CREATE_DATA_TABLE_SQL =
@@ -83,11 +84,13 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
                     DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
                     ")";
+    // 创建数据表，定义了与笔记相关数据的列，如ID、MIME类型、所属笔记ID、创建和修改日期、内容及其他通用数据列，设置ID为主键
 
     // 创建数据（DATA）表中根据笔记ID（NOTE_ID）的索引SQL语句
     private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
             "CREATE INDEX IF NOT EXISTS note_id_index ON " +
                     TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
+    // 创建一个索引，方便根据笔记ID快速查询相关数据
 
     /**
      * 当将笔记移动到文件夹时，增加文件夹的笔记数量
@@ -100,6 +103,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
                     "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
                     " END";
+    // 创建一个触发器，当笔记的父ID更新（即移动到新文件夹）时，增加目标文件夹的笔记数量
 
     /**
      * 当将笔记从文件夹中移出时，减少文件夹的笔记数量
@@ -113,6 +117,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
                     "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
                     " END";
+    // 创建一个触发器，当笔记的父ID更新（即从文件夹移出）时，减少原文件夹的笔记数量，但确保数量不小于0
 
     /**
      * 当向文件夹中插入新笔记时，增加文件夹的笔记数量
@@ -125,6 +130,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
                     "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
                     " END";
+    // 创建一个触发器，当新笔记插入时，增加其所属文件夹的笔记数量
 
     /**
      * 当从文件夹中删除笔记时，减少文件夹的笔记数量
@@ -138,6 +144,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
                     "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
                     " END";
+    // 创建一个触发器，当笔记被删除时，减少其所属文件夹的笔记数量，但确保数量不小于0
 
     /**
      * 当插入类型为{@link DataConstants#NOTE}的数据时，更新笔记的内容
@@ -151,6 +158,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
                     "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
                     " END";
+    // 创建一个触发器，当插入特定类型（DataConstants#NOTE）的数据时，更新对应笔记的内容
 
     /**
      * 当类型为{@link DataConstants#NOTE}的数据发生变化时，更新笔记的内容
@@ -164,6 +172,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
                     "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
                     " END";
+    // 创建一个触发器，当特定类型（DataConstants#NOTE）的数据更新时，更新对应笔记的内容
 
     /**
      * 当类型为{@link DataConstants#NOTE}的数据被删除时，更新笔记的内容
@@ -177,6 +186,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "   SET " + NoteColumns.SNIPPET + "=''" +
                     "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
                     " END";
+    // 创建一个触发器，当特定类型（DataConstants#NOTE）的数据被删除时，清空对应笔记的内容
 
     /**
      * 当笔记被删除时，删除属于该笔记的数据
@@ -188,6 +198,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "  DELETE FROM " + TABLE.DATA +
                     "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
                     " END";
+    // 创建一个触发器，当笔记被删除时，删除与之关联的数据
 
     /**
      * 当文件夹被删除时，删除属于该文件夹的笔记
@@ -199,6 +210,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "  DELETE FROM " + TABLE.NOTE +
                     "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
                     " END";
+    // 创建一个触发器，当文件夹被删除时，删除该文件夹下的所有笔记
 
     /**
      * 当文件夹被移动到回收站文件夹时，移动属于该文件夹的笔记
@@ -212,6 +224,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
                     "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
                     "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
                     " END";
+    // 创建一个触发器，当文件夹被移动到回收站时，将该文件夹下的所有笔记也移动到回收站
 
     // 构造函数，用于创建数据库帮助类实例
     public NotesDatabaseHelper(Context context) {
@@ -225,6 +238,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         createSystemFolder(db);
         Log.d(TAG, "note table has been created");
     }
+    // 执行创建笔记表的SQL语句，重新创建相关触发器，并创建系统文件夹，记录日志表示笔记表创建完成
 
     // 重新创建笔记表的触发器
     private void reCreateNoteTableTriggers(SQLiteDatabase db) {
@@ -244,6 +258,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
         db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
     }
+    // 删除旧的笔记表触发器，然后重新创建它们，以确保触发器的一致性和正确性
 
     // 创建系统文件夹
     private void createSystemFolder(SQLiteDatabase db) {
@@ -280,6 +295,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
         db.insert(TABLE.NOTE, null, values);
     }
+    // 创建各种系统文件夹，如通话记录文件夹、根文件夹、临时文件夹和回收站文件夹
 
     // 创建数据表
     public void createDataTable(SQLiteDatabase db) {
@@ -288,6 +304,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
         Log.d(TAG, "data table has been created");
     }
+    // 执行创建数据表的SQL语句，重新创建相关触发器，创建索引，并记录日志表示数据表创建完成
 
     // 重新创建数据表的触发器
     private void reCreateDataTableTriggers(SQLiteDatabase db) {
@@ -299,6 +316,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
         db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
     }
+    // 删除旧的数据表触发器，然后重新创建它们，以确保触发器的一致性和正确性
 
     // 获取单例实例
     static synchronized NotesDatabaseHelper getInstance(Context context) {
@@ -307,6 +325,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         }
         return mInstance;
     }
+    // 通过单例模式获取`NotesDatabaseHelper`实例，确保全局只有一个实例
 
     // 当数据库首次创建时调用
     @Override
@@ -314,6 +333,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
         createNoteTable(db);
         createDataTable(db);
     }
+    // 数据库首次创建时，调用创建笔记表和数据表的方法
 
     // 当数据库版本升级时调用
     @Override
diff --git a/src/Notes-master/src/net/micode/notes/data/NotesProvider.java b/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
index bc2ba39..c23b5c3 100644
--- a/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
+++ b/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
@@ -34,6 +34,7 @@ import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 
 // 内容提供者，用于管理笔记应用的数据访问
+// NotesProvider类是一个内容提供者，用于管理笔记应用的数据访问，提供了查询、插入、删除和更新数据的功能
 public class NotesProvider extends ContentProvider {
     // 用于匹配Uri的UriMatcher
     private static final UriMatcher mMatcher;
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
index 68fe0a6..81d779d 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
@@ -397,18 +397,25 @@ public class SqlNote {
         return true;
     }
 
-    // 获取当前笔记的内容，以JSONObject形式返回
+    // 获取内容的方法，返回一个表示当前对象内容的JSONObject
     public JSONObject getContent() {
         try {
+            // 创建一个空的JSONObject
             JSONObject js = new JSONObject();
 
+            // 如果该对象尚未在数据库中创建
             if (mIsCreate) {
+                // 记录错误日志
                 Log.e(TAG, "it seems that we haven't created this in database yet");
+                // 返回null
                 return null;
             }
 
+            // 创建一个表示笔记的JSONObject
             JSONObject note = new JSONObject();
+            // 如果类型是笔记类型
             if (mType == Notes.TYPE_NOTE) {
+                // 将笔记的各个属性添加到note JSONObject中
                 note.put(NoteColumns.ID, mId);
                 note.put(NoteColumns.ALERTED_DATE, mAlertDate);
                 note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@@ -421,124 +428,179 @@ public class SqlNote {
                 note.put(NoteColumns.WIDGET_ID, mWidgetId);
                 note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
                 note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
+                // 将表示笔记的note JSONObject添加到主JSONObject中，使用GTaskStringUtils.META_HEAD_NOTE作为键
                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
 
+                // 创建一个JSONArray用于存储数据
                 JSONArray dataArray = new JSONArray();
+                // 遍历数据列表
                 for (SqlData sqlData : mDataList) {
+                    // 获取每个数据项的内容JSONObject
                     JSONObject data = sqlData.getContent();
+                    // 如果数据项的内容JSONObject不为空
                     if (data!= null) {
+                        // 将其添加到JSONArray中
                         dataArray.put(data);
                     }
                 }
+                // 将存储数据的JSONArray添加到主JSONObject中，使用GTaskStringUtils.META_HEAD_DATA作为键
                 js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+                // 如果类型是文件夹或系统类型
             } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
+                // 将文件夹或系统类型的相关属性添加到note JSONObject中
                 note.put(NoteColumns.ID, mId);
                 note.put(NoteColumns.TYPE, mType);
                 note.put(NoteColumns.SNIPPET, mSnippet);
+                // 将表示文件夹或系统类型的note JSONObject添加到主JSONObject中，使用GTaskStringUtils.META_HEAD_NOTE作为键
                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
             }
 
+            // 返回构建好的主JSONObject
             return js;
         } catch (JSONException e) {
+            // 记录异常日志
             Log.e(TAG, e.toString());
+            // 打印异常堆栈信息
             e.printStackTrace();
         }
+        // 如果发生异常，返回null
         return null;
     }
 
+    // 设置父ID的方法
     public void setParentId(long id) {
+        // 设置对象的父ID
         mParentId = id;
+        // 将父ID的变化记录到mDiffNoteValues中，用于后续的更新操作
         mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
     }
 
+    // 设置GTask ID的方法
     public void setGtaskId(String gid) {
+        // 将GTask ID的变化记录到mDiffNoteValues中，用于后续的更新操作
         mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
     }
 
+    // 设置同步ID的方法
     public void setSyncId(long syncId) {
+        // 将同步ID的变化记录到mDiffNoteValues中，用于后续的更新操作
         mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
     }
 
+    // 重置本地修改标志的方法
     public void resetLocalModified() {
+        // 将本地修改标志设为0，并记录到mDiffNoteValues中，用于后续的更新操作
         mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
     }
 
+    // 获取ID的方法
     public long getId() {
+        // 返回对象的ID
         return mId;
     }
 
+    // 获取父ID的方法
     public long getParentId() {
+        // 返回对象的父ID
         return mParentId;
     }
 
+    // 获取片段内容的方法
     public String getSnippet() {
+        // 返回对象的片段内容
         return mSnippet;
     }
 
+    // 判断是否为笔记类型的方法
     public boolean isNoteType() {
+        // 如果类型是笔记类型，返回true，否则返回false
         return mType == Notes.TYPE_NOTE;
     }
 
+    // 提交更改的方法，validateVersion用于指定是否验证版本
     public void commit(boolean validateVersion) {
+        // 如果对象是新创建的
         if (mIsCreate) {
+            // 如果ID无效且mDiffNoteValues中包含ID，移除ID
             if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
                 mDiffNoteValues.remove(NoteColumns.ID);
             }
 
+            // 向笔记内容Uri插入数据，返回插入后的Uri
             Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
             try {
+                // 从返回的Uri中获取插入的笔记ID
                 mId = Long.valueOf(uri.getPathSegments().get(1));
             } catch (NumberFormatException e) {
+                // 记录获取ID错误的日志
                 Log.e(TAG, "Get note id error :" + e.toString());
+                // 抛出操作失败异常
                 throw new ActionFailureException("create note failed");
             }
+            // 如果获取的ID为0，抛出异常
             if (mId == 0) {
                 throw new IllegalStateException("Create thread id failed");
             }
 
+            // 如果类型是笔记类型
             if (mType == Notes.TYPE_NOTE) {
+                // 遍历数据列表，提交每个数据项
                 for (SqlData sqlData : mDataList) {
                     sqlData.commit(mId, false, -1);
                 }
             }
         } else {
-            if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
+            // 如果ID无效且不是根文件夹或通话记录文件夹的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 ++;
+                // 版本号加1
+                mVersion++;
                 int result = 0;
+                // 如果不需要验证版本
                 if (!validateVersion) {
+                    // 根据ID更新笔记数据
                     result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
                             + NoteColumns.ID + "=?)", new String[] {
-                        String.valueOf(mId)
+                            String.valueOf(mId)
                     });
                 } else {
+                    // 根据ID和版本号更新笔记数据
                     result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
-                            + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+                                    + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
                             new String[] {
                                     String.valueOf(mId), String.valueOf(mVersion)
                             });
                 }
+                // 如果更新结果为0，记录警告日志
                 if (result == 0) {
                     Log.w(TAG, "there is no update. maybe user updates note when syncing");
                 }
             }
 
+            // 如果类型是笔记类型
             if (mType == Notes.TYPE_NOTE) {
+                // 遍历数据列表，提交每个数据项
                 for (SqlData sqlData : mDataList) {
                     sqlData.commit(mId, validateVersion, mVersion);
                 }
             }
         }
 
-        // refresh local info
+        // 从数据库中重新加载本地信息
         loadFromCursor(mId);
+        // 如果类型是笔记类型，加载数据内容
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
 
+        // 清空记录变化的mDiffNoteValues
         mDiffNoteValues.clear();
+        // 设置对象不再是新创建的状态
         mIsCreate = false;
     }
 }