代码中注释提交3

src/Notesmaster/.idea/.name

@@ -0,0 +1 @@
+Notes-master

src/Notesmaster/.idea/deploymentTargetSelector.xml

@@ -4,10 +4,10 @@
     <selectionStates>
       <SelectionState runConfigName="app">
         <option name="selectionMode" value="DROPDOWN" />
-        <DropdownSelection timestamp="2024-11-08T15:24:08.657589200Z">
+        <DropdownSelection timestamp="2024-11-08T06:13:51.107266200Z">
           <Target type="DEFAULT_BOOT">
             <handle>
-              <DeviceId pluginId="LocalEmulator" identifier="path=D:\rj\androidSDK\.android\.android\avd\Pixel_Fold_API_VanillaIceCream.avd" />
+              <DeviceId pluginId="LocalEmulator" identifier="path=C:\Users\86183\.android\avd\Pixel_7_API_35.avd" />
             </handle>
           </Target>
         </DropdownSelection>
@@ -15,12 +15,15 @@
           <targets>
             <Target type="DEFAULT_BOOT">
               <handle>
-                <DeviceId pluginId="LocalEmulator" identifier="path=C:\Users\刘娟\.android\avd\Pixel_7_API_VanillaIceCream.avd" />
+                <DeviceId pluginId="LocalEmulator" identifier="path=C:\Users\86183\.android\avd\Pixel_7_API_35.avd" />
               </handle>
             </Target>
           </targets>
         </DialogSelection>
       </SelectionState>
+      <SelectionState runConfigName="MainActivity">
+        <option name="selectionMode" value="DROPDOWN" />
+      </SelectionState>
     </selectionStates>
   </component>
 </project>

src/Notesmaster/.idea/gradle.xml

@@ -6,6 +6,7 @@
       <GradleProjectSettings>
         <option name="testRunner" value="CHOOSE_PER_TEST" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleHome" value="$PROJECT_DIR$/../gradle/gradle-8.9" />
         <option name="gradleJvm" value="#GRADLE_LOCAL_JAVA_HOME" />
         <option name="modules">
           <set>

src/Notesmaster/.idea/misc.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="jbr-21" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build/classes" />
   </component>

src/Notesmaster/app/build.gradle.kts

@@ -26,8 +26,8 @@ android {
         }
     }
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
-        targetCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
     }
     packaging {
         resources.excludes.add("META-INF/DEPENDENCIES");
@@ -51,9 +51,9 @@ dependencies {
 //        "exclude" to listOf("")
 //    )))
     //修改为如下代码：
-    implementation(files("D:\\rj\\Notes-master\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-osgi-4.5.14.jar"))
-    implementation(files("D:\\rj\\Notes-master\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-win-4.5.14.jar"))
-    implementation(files("D:\\rj\\Notes-master\\httpcomponents-client-4.5.14-bin\\lib\\httpcore-4.4.16.jar"))
+    implementation(files("D:\\android\\Notesmaster\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-osgi-4.5.14.jar"))
+    implementation(files("D:\\android\\Notesmaster\\httpcomponents-client-4.5.14-bin\\lib\\httpclient-win-4.5.14.jar"))
+    implementation(files("D:\\android\\Notesmaster\\httpcomponents-client-4.5.14-bin\\lib\\httpcore-4.4.16.jar"))
     testImplementation(libs.junit)
     androidTestImplementation(libs.ext.junit)
     androidTestImplementation(libs.espresso.core)

src/Notesmaster/app/src/main/java/net/micode/notes/data/Contact.java

@@ -16,19 +16,29 @@
 
 package net.micode.notes.data;
 
+// 导入Context类
 import android.content.Context;
+// 导入Cursor类
 import android.database.Cursor;
+// 导入Phone类
 import android.provider.ContactsContract.CommonDataKinds.Phone;
+// 导入Data类
 import android.provider.ContactsContract.Data;
+// 导入PhoneNumberUtils类
 import android.telephony.PhoneNumberUtils;
+// 导入Log类
 import android.util.Log;
 
+// 导入HashMap类
 import java.util.HashMap;
 
 public class Contact {
+    // 定义一个静态的HashMap，用于缓存联系人信息
     private static HashMap<String, String> sContactCache;
+    // 定义一个常量，用于打印日志
     private static final String TAG = "Contact";
 
+    // 定义一个常量，用于查询联系人信息的SQL语句
     private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
     + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
     + " AND " + Data.RAW_CONTACT_ID + " IN "
@@ -36,17 +46,22 @@ public class Contact {
             + " FROM phone_lookup"
             + " WHERE min_match = '+')";
 
+// 根据传入的上下文和电话号码，获取联系人信息
     public static String getContact(Context context, String phoneNumber) {
+        // 如果sContactCache为空，则创建一个新的HashMap
         if(sContactCache == null) {
             sContactCache = new HashMap<String, String>();
         }
 
+        // 如果sContactCache中包含phoneNumber，则返回对应的联系人
         if(sContactCache.containsKey(phoneNumber)) {
             return sContactCache.get(phoneNumber);
         }
 
+// 将电话号码中的"+"替换为PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)方法返回的值
         String selection = CALLER_ID_SELECTION.replace("+",
                 PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+// 使用ContentResolver查询Data.CONTENT_URI，获取Phone.DISPLAY_NAME字段的值
         Cursor cursor = context.getContentResolver().query(
                 Data.CONTENT_URI,
                 new String [] { Phone.DISPLAY_NAME },
@@ -54,19 +69,28 @@ public class Contact {
                 new String[] { phoneNumber },
                 null);
 
+// 判断cursor是否为空，并且是否可以移动到第一行
         if (cursor != null && cursor.moveToFirst()) {
             try {
+        // 获取cursor中第一列的字符串
                 String name = cursor.getString(0);
+        // 将phoneNumber和name存入sContactCache中
                 sContactCache.put(phoneNumber, name);
+        // 返回name
                 return name;
             } catch (IndexOutOfBoundsException e) {
+        // 如果发生IndexOutOfBoundsException异常，打印错误日志
                 Log.e(TAG, " Cursor get string error " + e.toString());
+        // 返回null
                 return null;
             } finally {
+        // 关闭cursor
                 cursor.close();
             }
         } else {
+            // 打印日志，提示没有匹配到指定号码的联系人
             Log.d(TAG, "No contact matched with number:" + phoneNumber);
+            // 返回null
             return null;
         }
     }

src/Notesmaster/app/src/main/java/net/micode/notes/data/Notes.java

@@ -14,15 +14,19 @@
  * limitations under the License.
  */
 
+// 定义一个包，用于存放数据相关的类
 package net.micode.notes.data;
 
 import android.net.Uri;
+// 定义一个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;
+
+    // 定义Notes类的常量
+    public static final String AUTHORITY = "micode_notes"; // Notes类的授权
+    public static final String TAG = "Notes"; // Notes类的标签
+    public static final int TYPE_NOTE     = 0; // Notes类的类型常量，表示笔记
+    public static final int TYPE_FOLDER   = 1; // Notes类的类型常量，表示文件夹
+    public static final int TYPE_SYSTEM   = 2; // Notes类的类型常量，表示系统
 
     /**
      * Following IDs are system folders' identifiers
@@ -30,60 +34,77 @@ public class Notes {
      * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
      * {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
      */
+ // 定义根文件夹的ID
     public static final int ID_ROOT_FOLDER = 0;
+ // 定义临时文件夹的ID
     public static final int ID_TEMPARAY_FOLDER = -1;
+ // 定义通话记录文件夹的ID
     public static final int ID_CALL_RECORD_FOLDER = -2;
+ // 定义垃圾桶文件夹的ID
     public static final int ID_TRASH_FOLER = -3;
 
+// 定义一个常量，表示提醒日期的意图
     public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
+// 定义一个常量，表示背景颜色的意图
     public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
+// 定义一个常量，表示小部件的意图
     public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
+// 定义一个常量，表示小部件类型的意图
     public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
+// 定义一个常量，表示文件夹的意图
     public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
+// 定义一个常量，表示通话日期的意图
     public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
 
-    public static final int TYPE_WIDGET_INVALIDE      = -1;
-    public static final int TYPE_WIDGET_2X            = 0;
-    public static final int TYPE_WIDGET_4X            = 1;
+    public static final int TYPE_WIDGET_INVALIDE      = -1; // 无效的widget类型
+    public static final int TYPE_WIDGET_2X            = 0; // 2x的widget类型
+    public static final int TYPE_WIDGET_4X            = 1; // 4x的widget类型
 
     public static class DataConstants {
-        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
-        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
+        public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; // 文本笔记的类型
+        public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; // 呼叫笔记的类型
     }
 
     /**
      * Uri to query all notes and folders
      */
+// 定义一个常量，表示note的Uri
     public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
 
     /**
      * Uri to query data
      */
+// 定义一个常量，表示数据URI
     public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
 
+// 定义一个接口，表示笔记的列
     public interface NoteColumns {
         /**
          * The unique ID for a row
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，表示ID
         public static final String ID = "_id";
 
         /**
          * The parent's id for note or folder
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，表示父节点的ID
         public static final String PARENT_ID = "parent_id";
 
         /**
          * Created data for note or folder
          * <P> Type: INTEGER (long) </P>
          */
+ // 定义一个常量，表示创建日期
         public static final String CREATED_DATE = "created_date";
 
         /**
          * Latest modified date
          * <P> Type: INTEGER (long) </P>
          */
+// 声明一个常量，表示修改日期
         public static final String MODIFIED_DATE = "modified_date";
 
 
@@ -91,30 +112,35 @@ public class Notes {
          * Alert date
          * <P> Type: INTEGER (long) </P>
          */
+ // 定义一个常量，表示警报日期
         public static final String ALERTED_DATE = "alert_date";
 
         /**
          * Folder's name or text content of note
          * <P> Type: TEXT </P>
          */
+ // 定义一个常量，用于表示代码片段
         public static final String SNIPPET = "snippet";
 
         /**
          * Note's widget id
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，表示小部件的ID
         public static final String WIDGET_ID = "widget_id";
 
         /**
          * Note's widget type
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，表示小部件类型
         public static final String WIDGET_TYPE = "widget_type";
 
         /**
          * Note's background color's id
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，用于表示背景颜色的ID
         public static final String BG_COLOR_ID = "bg_color_id";
 
         /**
@@ -122,86 +148,101 @@ public class Notes {
          * note, it has at least one attachment
          * <P> Type: INTEGER </P>
          */
+// 定义一个常量，表示是否有附件
         public static final String HAS_ATTACHMENT = "has_attachment";
 
         /**
          * Folder's count of notes
          * <P> Type: INTEGER (long) </P>
          */
+// 声明一个常量，用于存储笔记数量
         public static final String NOTES_COUNT = "notes_count";
 
         /**
          * The file type: folder or note
          * <P> Type: INTEGER </P>
          */
+// 定义一个常量，表示类型
         public static final String TYPE = "type";
 
         /**
          * The last sync id
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，用于同步的ID
         public static final String SYNC_ID = "sync_id";
 
         /**
          * Sign to indicate local modified or not
          * <P> Type: INTEGER </P>
          */
+// 定义一个常量，表示本地修改
         public static final String LOCAL_MODIFIED = "local_modified";
 
         /**
          * Original parent id before moving into temporary folder
          * <P> Type : INTEGER </P>
          */
+// 定义一个常量，表示原始父级ID
         public static final String ORIGIN_PARENT_ID = "origin_parent_id";
 
         /**
          * The gtask id
          * <P> Type : TEXT </P>
          */
+ // 声明一个常量字符串，用于表示任务ID
         public static final String GTASK_ID = "gtask_id";
 
         /**
          * The version code
          * <P> Type : INTEGER (long) </P>
          */
+// 定义一个常量，表示版本号
         public static final String VERSION = "version";
     }
 
+    // 定义一个接口DataColumns
     public interface DataColumns {
         /**
          * The unique ID for a row
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，表示ID
         public static final String ID = "_id";
 
         /**
          * The MIME type of the item represented by this row.
          * <P> Type: Text </P>
          */
+// 定义一个常量，表示MIME类型
         public static final String MIME_TYPE = "mime_type";
 
         /**
          * The reference id to note that this data belongs to
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，表示笔记的ID
         public static final String NOTE_ID = "note_id";
 
         /**
          * Created data for note or folder
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，表示创建日期
         public static final String CREATED_DATE = "created_date";
 
         /**
          * Latest modified date
          * <P> Type: INTEGER (long) </P>
          */
+// 定义一个常量，表示修改日期
         public static final String MODIFIED_DATE = "modified_date";
 
         /**
          * Data's content
          * <P> Type: TEXT </P>
          */
+// 定义一个常量CONTENT，值为"content"
         public static final String CONTENT = "content";
 
 
@@ -210,6 +251,7 @@ public class Notes {
          * integer data type
          * <P> Type: INTEGER </P>
          */
+// 定义一个常量DATA1，值为"data1"
         public static final String DATA1 = "data1";
 
         /**
@@ -217,6 +259,7 @@ public class Notes {
          * integer data type
          * <P> Type: INTEGER </P>
          */
+// 定义一个常量DATA2，值为"data2"
         public static final String DATA2 = "data2";
 
         /**
@@ -224,6 +267,7 @@ public class Notes {
          * TEXT data type
          * <P> Type: TEXT </P>
          */
+// 定义一个常量DATA3，值为"data3"
         public static final String DATA3 = "data3";
 
         /**
@@ -231,6 +275,7 @@ public class Notes {
          * TEXT data type
          * <P> Type: TEXT </P>
          */
+// 定义一个常量DATA4，值为"data4"
         public static final String DATA4 = "data4";
 
         /**
@@ -238,30 +283,39 @@ public class Notes {
          * TEXT data type
          * <P> Type: TEXT </P>
          */
+// 定义一个常量DATA5，值为"data5"
         public static final String DATA5 = "data5";
     }
 
+    // 实现DataColumns接口的TextNote类
     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>
          */
+// 定义一个常量MODE，其值为DATA1
         public static final String MODE = DATA1;
 
+        // 定义一个常量，表示检查列表的模式
         public static final int MODE_CHECK_LIST = 1;
 
+        // 定义一个常量，表示内容类型为文本笔记
         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
 
+        // 定义一个常量，表示内容项类型为文本笔记
         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
 
+        // 定义一个常量，表示内容URI，用于访问文本笔记数据
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
     }
 
+// 定义一个名为CallNote的公共静态最终类，实现DataColumns接口
     public static final class CallNote implements DataColumns {
         /**
          * Call date for this record
          * <P> Type: INTEGER (long) </P>
          */
+ // 定义一个常量CALL_DATE，其值为DATA1
         public static final String CALL_DATE = DATA1;
 
         /**
@@ -270,10 +324,13 @@ public class Notes {
          */
         public static final String PHONE_NUMBER = DATA3;
 
+        // 定义内容类型，表示这是一个目录
         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
 
+        // 定义内容项类型，表示这是一个单个项
         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
 
+        // 定义内容URI，用于访问数据
         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
     }
 }

src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+// 定义一个包，用于存放数据相关的类
 package net.micode.notes.data;
 
 import android.content.ContentValues;
@@ -22,340 +23,474 @@ import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.util.Log;
 
+// 导入Notes类中的DataColumns和DataConstants常量
 import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.DataConstants;
+// 导入Notes类中的NoteColumns常量
 import net.micode.notes.data.Notes.NoteColumns;
 
 
 public class NotesDatabaseHelper extends SQLiteOpenHelper {
+    // 数据库名称
     private static final String DB_NAME = "note.db";
 
+    // 数据库版本号
     private static final int DB_VERSION = 4;
 
     public interface TABLE {
+        // 定义一个常量，表示note
         public static final String NOTE = "note";
 
+        // 定义一个常量，表示data
         public static final String DATA = "data";
     }
 
+ // 定义一个常量，用于标识数据库帮助类的标签
     private static final String TAG = "NotesDatabaseHelper";
 
+ // 定义一个静态变量，用于存储数据库帮助类的实例
     private static NotesDatabaseHelper mInstance;
 
+// 定义创建NOTE表的SQL语句
     private static final String CREATE_NOTE_TABLE_SQL =
         "CREATE TABLE " + TABLE.NOTE + "(" +
+            // 定义ID列，类型为INTEGER，为主键
             NoteColumns.ID + " INTEGER PRIMARY KEY," +
+            // 定义PARENT_ID列，类型为INTEGER，默认值为0
             NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义ALERTED_DATE列，类型为INTEGER，默认值为0
             NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义BG_COLOR_ID列，类型为INTEGER，默认值为0
             NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义CREATED_DATE列，类型为INTEGER，默认值为当前时间戳
             NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // 定义HAS_ATTACHMENT列，类型为INTEGER，默认值为0
             NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义MODIFIED_DATE列，类型为INTEGER，默认值为当前时间戳
             NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // 定义NOTES_COUNT列，类型为INTEGER，默认值为0
             NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义SNIPPET列，类型为TEXT，默认值为空字符串
             NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
+            // 定义TYPE列，类型为INTEGER，默认值为0
             NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义WIDGET_ID列，类型为INTEGER，默认值为0
             NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义WIDGET_TYPE列，类型为INTEGER，默认值为-1
             NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
+            // 定义SYNC_ID列，类型为INTEGER，默认值为0
             NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义LOCAL_MODIFIED列，类型为INTEGER，默认值为0
             NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义ORIGIN_PARENT_ID列，类型为INTEGER，默认值为0
             NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义GTASK_ID列，类型为TEXT，默认值为空字符串
             NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
+            // 定义VERSION列，类型为INTEGER，默认值为0
             NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
         ")";
 
+// 定义创建数据表的SQL语句
     private static final String CREATE_DATA_TABLE_SQL =
         "CREATE TABLE " + TABLE.DATA + "(" +
+            // 定义ID列，类型为INTEGER，为主键
             DataColumns.ID + " INTEGER PRIMARY KEY," +
+            // 定义MIME_TYPE列，类型为TEXT，不能为空
             DataColumns.MIME_TYPE + " TEXT NOT NULL," +
+            // 定义NOTE_ID列，类型为INTEGER，不能为空，默认值为0
             DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
+            // 定义CREATED_DATE列，类型为INTEGER，不能为空，默认值为当前时间
             NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // 定义MODIFIED_DATE列，类型为INTEGER，不能为空，默认值为当前时间
             NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+            // 定义CONTENT列，类型为TEXT，不能为空，默认值为空字符串
             DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +
+            // 定义DATA1列，类型为INTEGER
             DataColumns.DATA1 + " INTEGER," +
+            // 定义DATA2列，类型为INTEGER
             DataColumns.DATA2 + " INTEGER," +
+            // 定义DATA3列，类型为TEXT，不能为空，默认值为空字符串
             DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
+            // 定义DATA4列，类型为TEXT，不能为空，默认值为空字符串
             DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
+            // 定义DATA5列，类型为TEXT，不能为空，默认值为空字符串
             DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
         ")";
 
+// 定义一个常量，用于创建索引的SQL语句
     private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
+// 创建一个名为note_id_index的索引，如果不存在
         "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
      */
+// 定义一个静态常量，用于创建一个触发器，在更新Note表的PARENT_ID字段后，增加对应文件夹的NOTES_COUNT字段
     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";
+        "CREATE TRIGGER increase_folder_count_on_update "+ // 创建一个触发器，名称为increase_folder_count_on_update
+        " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + // 在Note表上，当PARENT_ID字段更新后
+        " BEGIN " + // 开始
+        "  UPDATE " + TABLE.NOTE + // 更新NOTE表
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + // 将NOTES_COUNT字段加1
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + // 将ID字段与new.PARENT_ID字段相等
+        " END"; // 结束
 
     /**
      * Decrease folder's note count when move note from folder
      */
+// 定义一个常量，用于表示在更新触发器中减少文件夹数量的操作
     private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+ // 创建一个触发器，在更新 NoteColumns.PARENT_ID 列后，减少 TABLE 表中的文件夹数量
         "CREATE TRIGGER decrease_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 + "=old." + NoteColumns.PARENT_ID +
-        "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
-        " END";
+        "  UPDATE " + TABLE.NOTE + // 更新NOTE表
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + // 将NOTES_COUNT字段减1
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + // 条件：ID等于old表中的PARENT_ID
+        "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" + // 条件：NOTES_COUNT大于0
+        " 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 " +
         " AFTER INSERT ON " + TABLE.NOTE +
         " BEGIN " +
-        "  UPDATE " + TABLE.NOTE +
-        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
-        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
-        " END";
+        "  UPDATE " + TABLE.NOTE + // 更新NOTE表
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" + // 将NOTES_COUNT字段加1
+        "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" + // 将ID字段与new.PARENT_ID字段相等
+        " 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 " +
         " AFTER DELETE ON " + TABLE.NOTE +
         " BEGIN " +
-        "  UPDATE " + TABLE.NOTE +
-        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
-        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
-        "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
+        "  UPDATE " + TABLE.NOTE + // 更新NOTE表
+        "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" + // 将NOTES_COUNT字段减1
+        "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID + // 条件为ID等于old表中的PARENT_ID
+        "  AND " + NoteColumns.NOTES_COUNT + ">0;" + // 且NOTES_COUNT大于0
         " END";
 
     /**
      * 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 +
         " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
-        " BEGIN" +
-        "  UPDATE " + TABLE.NOTE +
-        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
-        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
-        " END";
+        " BEGIN" + // 开始事务
+        "  UPDATE " + TABLE.NOTE + // 更新NOTE表
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // 将新内容的值赋给NOTE表的SNIPPET列
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // 根据新内容的NOTE_ID找到NOTE表中的ID，并更新SNIPPET列
+        " END"; // 结束事务
 
     /**
      * 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 +
         " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
         " BEGIN" +
-        "  UPDATE " + TABLE.NOTE +
-        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
-        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
-        " END";
+        "  UPDATE " + TABLE.NOTE + // 更新NOTE表
+        "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT + // 将新内容的值赋给NOTE表的SNIPPET列
+        "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" + // 将NOTE表的ID列的值与新内容的NOTE_ID列的值进行比较
+        " END"; // 结束
 
     /**
      * 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 +
         " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
-        " BEGIN" +
-        "  UPDATE " + TABLE.NOTE +
-        "   SET " + NoteColumns.SNIPPET + "=''" +
-        "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
-        " END";
+        " BEGIN" + // 开始事务
+        "  UPDATE " + TABLE.NOTE + // 更新NOTE表
+        "   SET " + NoteColumns.SNIPPET + "=''" + // 将SNIPPET字段设置为空字符串
+        "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" + // 根据ID字段和old中的NOTE_ID字段进行更新
+        " 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 " +
-        " AFTER DELETE ON " + TABLE.NOTE +
-        " BEGIN" +
-        "  DELETE FROM " + TABLE.DATA +
-        "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
-        " END";
+        "CREATE TRIGGER delete_data_on_delete " + // 创建一个名为delete_data_on_delete的触发器
+        " AFTER DELETE ON " + TABLE.NOTE + // 在删除NOTE表中的数据后触发
+        " BEGIN" + // 开始事务
+        "  DELETE FROM " + TABLE.DATA + // 从DATA表中删除数据
+        "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" + // 条件为NOTE_ID等于old中的ID
+        " 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 " +
         " AFTER DELETE ON " + TABLE.NOTE +
         " BEGIN" +
+  // 删除与该笔记相关的所有笔记
         "  DELETE FROM " + TABLE.NOTE +
+        // 从笔记表中删除
         "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
+        // 条件为该笔记的ID等于旧笔记的ID
         " 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 " +
         " AFTER UPDATE ON " + TABLE.NOTE +
         " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
-        " BEGIN" +
-        "  UPDATE " + TABLE.NOTE +
-        "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
-        "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
-        " END";
+        " BEGIN" + // 开始事务
+        "  UPDATE " + TABLE.NOTE + // 更新NOTE表
+        "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER + // 将PARENT_ID设置为回收站ID
+        "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" + // 将PARENT_ID等于old.ID的记录更新
+        " END"; // 结束事务
 
+ // 构造函数，用于初始化NotesDatabaseHelper对象
     public NotesDatabaseHelper(Context context) {
+        // 调用父类的构造函数，传入上下文、数据库名称、游标工厂、数据库版本号
         super(context, DB_NAME, null, DB_VERSION);
     }
 
     public void createNoteTable(SQLiteDatabase db) {
+        // 执行创建note表的SQL语句
         db.execSQL(CREATE_NOTE_TABLE_SQL);
+        // 重新创建note表的触发器
         reCreateNoteTableTriggers(db);
+        // 创建系统文件夹
         createSystemFolder(db);
+        // 打印日志，note表已创建
         Log.d(TAG, "note table has been created");
     }
 
     private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+        // 删除increase_folder_count_on_update触发器
         db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
+        // 删除decrease_folder_count_on_update触发器
         db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
+        // 删除decrease_folder_count_on_delete触发器
         db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
+        // 删除delete_data_on_delete触发器
         db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
+        // 删除increase_folder_count_on_insert触发器
         db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
+        // 删除folder_delete_notes_on_delete触发器
         db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
+        // 删除folder_move_notes_on_trash触发器
         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);
+// 执行删除数据触发器
         db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
+// 执行增加文件夹计数触发器
         db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
+// 执行删除文件夹触发器
         db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
+// 执行移动文件夹触发器
         db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
     }
 
+ // 创建系统文件夹
     private void createSystemFolder(SQLiteDatabase db) {
+        // 创建ContentValues对象，用于存储数据
         ContentValues values = new ContentValues();
 
         /**
          * call record foler for call notes
          */
+// 将Notes.ID_CALL_RECORD_FOLDER的值放入values中
         values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
+// 将Notes.TYPE_SYSTEM的值放入values中
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将values中的值插入到TABLE.NOTE表中
         db.insert(TABLE.NOTE, null, values);
 
         /**
          * root folder which is default folder
          */
+// 清空values
         values.clear();
+// 将Notes.ID_ROOT_FOLDER放入values中
         values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
+// 将Notes.TYPE_SYSTEM放入values中
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将values插入到TABLE.NOTE表中
         db.insert(TABLE.NOTE, null, values);
 
         /**
          * temporary folder which is used for moving note
          */
+ // 清空values
         values.clear();
+ // 将NoteColumns.ID的值设为Notes.ID_TEMPARAY_FOLDER
         values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+ // 将NoteColumns.TYPE的值设为Notes.TYPE_SYSTEM
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+ // 将values插入到TABLE.NOTE表中
         db.insert(TABLE.NOTE, null, values);
 
         /**
          * create trash folder
          */
+// 清空values
         values.clear();
+// 将NoteColumns.ID的值设为Notes.ID_TRASH_FOLER
         values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+// 将NoteColumns.TYPE的值设为Notes.TYPE_SYSTEM
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将values插入到TABLE.NOTE表中
         db.insert(TABLE.NOTE, null, values);
     }
 
     public void createDataTable(SQLiteDatabase db) {
+        // 执行创建数据表的SQL语句
         db.execSQL(CREATE_DATA_TABLE_SQL);
+        // 重新创建数据表触发器
         reCreateDataTableTriggers(db);
+        // 执行创建数据表索引的SQL语句
         db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
+        // 打印日志，表示数据表已经创建
         Log.d(TAG, "data table has been created");
     }
 
+// 重新创建数据表触发器
     private void reCreateDataTableTriggers(SQLiteDatabase db) {
+        // 删除update_note_content_on_insert触发器
         db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
+        // 删除update_note_content_on_update触发器
         db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
+        // 删除update_note_content_on_delete触发器
         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实例
     static synchronized NotesDatabaseHelper getInstance(Context context) {
+        // 如果mInstance为空，则创建一个新的NotesDatabaseHelper实例
         if (mInstance == null) {
             mInstance = new NotesDatabaseHelper(context);
         }
+        // 返回mInstance实例
         return mInstance;
     }
 
     @Override
+    // 重写onCreate方法，当数据库创建时调用
     public void onCreate(SQLiteDatabase db) {
+        // 创建Note表
         createNoteTable(db);
+        // 创建Data表
         createDataTable(db);
     }
 
+ // 重写onUpgrade方法，当数据库版本升级时调用
     @Override
     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        // 是否重新创建触发器
         boolean reCreateTriggers = false;
+        // 是否跳过V2版本
         boolean skipV2 = false;
 
+        // 如果旧版本为1，则升级到v2版本
         if (oldVersion == 1) {
             upgradeToV2(db);
             skipV2 = true; // this upgrade including the upgrade from v2 to v3
             oldVersion++;
         }
 
+// 如果旧版本为2且不跳过V2版本，则升级到V3版本，并重新创建触发器，同时旧版本加1
         if (oldVersion == 2 && !skipV2) {
             upgradeToV3(db);
             reCreateTriggers = true;
             oldVersion++;
         }
 
+// 如果旧版本号为3
         if (oldVersion == 3) {
+            // 升级到版本4
             upgradeToV4(db);
+            // 版本号加1
             oldVersion++;
         }
 
+ // 如果需要重新创建触发器，则执行以下操作
         if (reCreateTriggers) {
+            // 重新创建NoteTable触发器
             reCreateNoteTableTriggers(db);
+            // 重新创建DataTable触发器
             reCreateDataTableTriggers(db);
         }
 
-        if (oldVersion != newVersion) {
+// 如果旧版本不等于新版本，则抛出异常
+       if (oldVersion != newVersion) {
             throw new IllegalStateException("Upgrade notes database to version " + newVersion
                     + "fails");
         }
-    }
+    } 
 
     private void upgradeToV2(SQLiteDatabase db) {
+        // 删除旧版本的NOTE表
         db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
+        // 删除旧版本的DATA表
         db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+        // 创建新版本的NOTE表
         createNoteTable(db);
+        // 创建新版本的DATA表
         createDataTable(db);
     }
 
+ // 将数据库升级到V3版本
     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
+// 向数据库中的NOTE表添加一个名为GTASK_ID的列，类型为TEXT，默认值为空字符串
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
                 + " TEXT NOT NULL DEFAULT ''");
         // add a trash system folder
+// 创建一个ContentValues对象，用于存储要插入的数据
         ContentValues values = new ContentValues();
+// 将ID_TRASH_FOLER的值放入NoteColumns.ID字段中
         values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+// 将TYPE_SYSTEM的值放入NoteColumns.TYPE字段中
         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+// 将values中的数据插入到TABLE.NOTE表中
         db.insert(TABLE.NOTE, null, values);
     }
 
+// 将数据库升级到V4版本
     private void upgradeToV4(SQLiteDatabase db) {
+        // 执行SQL语句，向NOTE表中添加VERSION列，类型为INTEGER，默认值为0
+// 向数据库中的NOTE表添加一个名为VERSION的列，类型为INTEGER，默认值为0
         db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
                 + " INTEGER NOT NULL DEFAULT 0");
     }

src/Notesmaster/app/src/main/java/net/micode/notes/data/NotesProvider.java

@@ -14,50 +14,72 @@
  * limitations under the License.
  */
 
+// 定义一个包，用于存放数据相关的类
 package net.micode.notes.data;
 
 
-import android.app.SearchManager;
-import android.content.ContentProvider;
-import android.content.ContentUris;
-import android.content.ContentValues;
-import android.content.Intent;
+import android.app.SearchManager; // 导入SearchManager类
+import android.content.ContentProvider; // 导入ContentProvider类
+import android.content.ContentUris; // 导入ContentUris类
+import android.content.ContentValues; // 导入ContentValues类
+import android.content.Intent; // 导入Intent类
 import android.content.UriMatcher;
+// UriMatcher用于匹配Uri
 import android.database.Cursor;
+// Cursor用于查询数据库
 import android.database.sqlite.SQLiteDatabase;
+// SQLiteDatabase用于操作数据库
 import android.net.Uri;
+// Uri用于表示数据源
 import android.text.TextUtils;
 import android.util.Log;
 
+// 导入NotesDatabaseHelper类中的TABLE常量
 import net.micode.notes.R;
 import net.micode.notes.data.Notes.DataColumns;
+// 导入Notes类中的NoteColumns接口
 import net.micode.notes.data.Notes.NoteColumns;
+// 导入NotesDatabaseHelper类中的TABLE常量
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 
 
 public class NotesProvider extends ContentProvider {
+    // 定义一个UriMatcher对象，用于匹配Uri
     private static final UriMatcher mMatcher;
 
+    // 定义一个NotesDatabaseHelper对象，用于操作数据库
     private NotesDatabaseHelper mHelper;
 
+    // 定义日志标签
     private static final String TAG = "NotesProvider";
 
+    // 定义URI常量
     private static final int URI_NOTE            = 1;
     private static final int URI_NOTE_ITEM       = 2;
     private static final int URI_DATA            = 3;
     private static final int URI_DATA_ITEM       = 4;
 
+    // 定义搜索URI常量
     private static final int URI_SEARCH          = 5;
     private static final int URI_SEARCH_SUGGEST  = 6;
 
+// 静态代码块，用于初始化UriMatcher对象
     static {
+        // 创建UriMatcher对象，NO_MATCH表示没有匹配的URI
         mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        // 添加URI匹配规则，匹配Notes.AUTHORITY下的note，匹配成功返回URI_NOTE
         mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
+        // 添加URI匹配规则，匹配Notes.AUTHORITY下的note/#，匹配成功返回URI_NOTE_ITEM
         mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
+        // 添加URI匹配规则，匹配Notes.AUTHORITY下的data，匹配成功返回URI_DATA
         mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
+        // 添加URI匹配规则，匹配Notes.AUTHORITY下的data/#，匹配成功返回URI_DATA_ITEM
         mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
+        // 添加URI匹配规则，匹配Notes.AUTHORITY下的search，匹配成功返回URI_SEARCH
         mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
+        // 添加URI匹配规则，匹配Notes.AUTHORITY下的search/*，匹配成功返回URI_SEARCH_SUGGEST
         mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
+        // 添加URI匹配规则，匹配Notes.AUTHORITY下的search/*/*，匹配成功返回URI_SEARCH_SUGGEST
         mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
     }
 
@@ -65,234 +87,346 @@ public class NotesProvider extends ContentProvider {
      * x'0A' represents the '\n' character in sqlite. For title and content in the search result,
      * we will trim '\n' and white space in order to show more information.
      */
+// 定义搜索笔记的投影
     private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
         + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
+        // 将NoteColumns.SNIPPET中的换行符替换为空字符串，并去除首尾空格，作为SearchManager.SUGGEST_COLUMN_TEXT_1的值
         + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
+        // 将NoteColumns.SNIPPET中的换行符替换为空字符串，并去除首尾空格，作为SearchManager.SUGGEST_COLUMN_TEXT_2的值
         + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
+// 添加搜索结果图标
         + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
+// 添加搜索结果意图动作
         + "'" + 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
+        // 查询表名为NOTE的表
         + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
+        // 查询SNIPPET字段中包含指定字符的记录
         + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+        // 查询PARENT_ID字段不等于指定值的记录
         + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
 
     @Override
     public boolean onCreate() {
+        // 获取NotesDatabaseHelper的实例
+// 获取NotesDatabaseHelper的实例
         mHelper = NotesDatabaseHelper.getInstance(getContext());
+// 返回true
         return true;
     }
 
     @Override
+// 根据给定的Uri、投影、选择条件和排序顺序查询数据
     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
             String sortOrder) {
+        // 声明一个Cursor对象
         Cursor c = null;
+        // 获取可读的数据库
         SQLiteDatabase db = mHelper.getReadableDatabase();
+        // 声明一个id变量
         String id = null;
+        // 根据uri匹配对应的操作
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
+                // 查询数据库
                 c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
             case URI_NOTE_ITEM:
+                // 获取uri路径中的id
                 id = uri.getPathSegments().get(1);
+                // 根据id查询note表
                 c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
             case URI_DATA:
+                // 查询data表
                 c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
             case URI_DATA_ITEM:
+                // 获取uri路径中的id
                 id = uri.getPathSegments().get(1);
+                // 根据id查询data表
                 c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
             case URI_SEARCH:
             case URI_SEARCH_SUGGEST:
+                // 如果指定了排序方式、投影、选择条件或选择参数，则抛出异常
                 if (sortOrder != null || projection != null) {
                     throw new IllegalArgumentException(
                             "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
                 }
 
+// 定义一个字符串变量searchString，初始值为null
                 String searchString = null;
+// 如果mMatcher.match(uri)等于URI_SEARCH_SUGGEST
                 if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
+    // 如果uri的路径段大小大于1
                     if (uri.getPathSegments().size() > 1) {
+        // 将uri的路径段的第二个元素赋值给searchString
                         searchString = uri.getPathSegments().get(1);
                     }
+// 否则
                 } else {
+    // 将uri的查询参数中名为"pattern"的值赋值给searchString
                     searchString = uri.getQueryParameter("pattern");
                 }
 
+// 如果searchString为空
                 if (TextUtils.isEmpty(searchString)) {
+    // 返回null
                     return null;
                 }
 
                 try {
+                    // 将搜索字符串格式化为包含通配符的字符串
                     searchString = String.format("%%%s%%", searchString);
+                    // 执行数据库查询
                     c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
                             new String[] { searchString });
                 } catch (IllegalStateException ex) {
+                    // 捕获异常并打印错误日志
                     Log.e(TAG, "got exception: " + ex.toString());
                 }
                 break;
             default:
+                // 抛出异常，表示未知的URI
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
+        // 如果查询结果不为空，则设置通知URI
         if (c != null) {
             c.setNotificationUri(getContext().getContentResolver(), uri);
         }
+        // 返回查询结果
         return c;
     }
 
     @Override
     public Uri insert(Uri uri, ContentValues values) {
+        // 获取可写的数据库
         SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 定义变量，用于存储插入的数据ID
         long dataId = 0, noteId = 0, insertedId = 0;
+        // 根据传入的URI匹配对应的操作
         switch (mMatcher.match(uri)) {
+            // 如果匹配到的是NOTE表
             case URI_NOTE:
+                // 在NOTE表中插入数据，并返回插入的数据ID
                 insertedId = noteId = db.insert(TABLE.NOTE, null, values);
                 break;
             case URI_DATA:
+                // 如果values中包含NOTE_ID，则获取其值，否则打印错误日志
                 if (values.containsKey(DataColumns.NOTE_ID)) {
                     noteId = values.getAsLong(DataColumns.NOTE_ID);
                 } else {
                     Log.d(TAG, "Wrong data format without note id:" + values.toString());
                 }
+                // 将values插入到数据库中，并获取插入的id
                 insertedId = dataId = db.insert(TABLE.DATA, null, values);
                 break;
             default:
+                // 如果uri不匹配，则抛出异常
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
         // Notify the note uri
+// 如果noteId大于0，则通知ContentResolver，有数据发生变化
         if (noteId > 0) {
             getContext().getContentResolver().notifyChange(
+                    // 使用ContentUris.withAppendedId方法，将noteId添加到Notes.CONTENT_NOTE_URI中
                     ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
         }
 
         // Notify the data uri
+// 如果dataId大于0，则通知ContentResolver数据已更改
         if (dataId > 0) {
             getContext().getContentResolver().notifyChange(
                     ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
         }
 
+// 返回插入的ID与uri的拼接结果
         return ContentUris.withAppendedId(uri, insertedId);
     }
 
     @Override
     public int delete(Uri uri, String selection, String[] selectionArgs) {
+        // 初始化删除的记录数
         int count = 0;
+        // 初始化id
         String id = null;
+        // 获取可写的数据库
         SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 标记是否删除数据
         boolean deleteData = false;
+// 根据uri匹配的值，执行不同的操作
         switch (mMatcher.match(uri)) {
+    // 如果uri匹配的是URI_NOTE
             case URI_NOTE:
+        // 在selection中添加条件，NoteColumns.ID大于0
                 selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
+        // 执行删除操作，返回删除的行数
                 count = db.delete(TABLE.NOTE, selection, selectionArgs);
                 break;
+    // 如果uri匹配的是URI_NOTE_ITEM
             case URI_NOTE_ITEM:
+        // 获取uri路径中的第二个参数，即id
                 id = uri.getPathSegments().get(1);
                 /**
                  * ID that smaller than 0 is system folder which is not allowed to
                  * trash
                  */
+// 将id转换为long类型
                 long noteId = Long.valueOf(id);
+// 如果noteId小于等于0，则跳出循环
                 if (noteId <= 0) {
                     break;
                 }
+// 删除note表中id等于id的记录，并返回删除的记录数
                 count = db.delete(TABLE.NOTE,
                         NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+// 跳出循环
                 break;
+// 如果uri为URI_DATA，则删除data表中满足selection条件的记录，并返回删除的记录数
             case URI_DATA:
                 count = db.delete(TABLE.DATA, selection, selectionArgs);
+    // 标记删除data表中的记录
                 deleteData = true;
                 break;
+// 如果uri为URI_DATA_ITEM，则获取uri中的第二个路径段作为id，删除data表中id等于id的记录，并返回删除的记录数
             case URI_DATA_ITEM:
                 id = uri.getPathSegments().get(1);
                 count = db.delete(TABLE.DATA,
                         DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+    // 标记删除data表中的记录
                 deleteData = true;
                 break;
+// 如果uri不是以上两种情况，则抛出异常
             default:
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
+// 如果count大于0
         if (count > 0) {
+    // 如果deleteData为true
             if (deleteData) {
+        // 通知ContentResolver，Notes.CONTENT_NOTE_URI发生了变化
                 getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
             }
+    // 通知ContentResolver，uri发生了变化
             getContext().getContentResolver().notifyChange(uri, null);
         }
+// 返回count的值
         return count;
     }
 
     @Override
     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+        // 定义更新条数
         int count = 0;
+        // 定义id
         String id = null;
+        // 获取可写数据库
         SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 定义是否更新数据
         boolean updateData = false;
+        // 根据uri匹配对应的操作
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
+                // 增加note版本号
                 increaseNoteVersion(-1, selection, selectionArgs);
+                // 更新数据
                 count = db.update(TABLE.NOTE, values, selection, selectionArgs);
                 break;
             case URI_NOTE_ITEM:
+                // 获取URI中的路径段，获取id
                 id = uri.getPathSegments().get(1);
+                // 增加笔记版本号
                 increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
+                // 更新数据库中的笔记信息
                 count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs);
                 break;
             case URI_DATA:
+                // 更新数据表中的数据
                 count = db.update(TABLE.DATA, values, selection, selectionArgs);
+                // 标记更新数据
                 updateData = true;
                 break;
             case URI_DATA_ITEM:
+                // 获取URI中的数据项ID
                 id = uri.getPathSegments().get(1);
+                // 更新数据表中的数据项
                 count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs);
+                // 标记更新数据
                 updateData = true;
                 break;
             default:
+                // 抛出异常，未知URI
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
 
+// 如果count大于0
         if (count > 0) {
+    // 如果updateData为true
             if (updateData) {
+        // 通知ContentResolver更新Notes.CONTENT_NOTE_URI
                 getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
             }
+    // 通知ContentResolver更新uri
             getContext().getContentResolver().notifyChange(uri, null);
         }
+// 返回count
         return count;
     }
 
+// 解析selection字符串
     private String parseSelection(String selection) {
+    // 如果selection不为空
         return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
     }
 
+// 增加笔记版本号
     private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+        // 创建一个StringBuilder对象，用于拼接SQL语句
         StringBuilder sql = new StringBuilder(120);
+        // 拼接UPDATE语句
         sql.append("UPDATE ");
+        // 拼接表名
         sql.append(TABLE.NOTE);
+        // 拼接SET语句
         sql.append(" SET ");
+        // 拼接版本号字段
         sql.append(NoteColumns.VERSION);
+        // 拼接版本号增加1的语句
         sql.append("=" + NoteColumns.VERSION + "+1 ");
 
+// 如果id大于0或者selection不为空，则添加WHERE关键字
         if (id > 0 || !TextUtils.isEmpty(selection)) {
             sql.append(" WHERE ");
         }
+// 如果id大于0，则添加id等于id的语句
         if (id > 0) {
             sql.append(NoteColumns.ID + "=" + String.valueOf(id));
         }
+// 如果selection不为空，则解析selection并添加到sql语句中
         if (!TextUtils.isEmpty(selection)) {
             String selectString = id > 0 ? parseSelection(selection) : selection;
+// 遍历selectionArgs数组中的每一个元素
             for (String args : selectionArgs) {
+                // 将selectString中的第一个"?"替换为args
                 selectString = selectString.replaceFirst("\\?", args);
             }
+            // 将替换后的selectString添加到sql中
             sql.append(selectString);
         }
 
+// 获取可写的数据库
         mHelper.getWritableDatabase().execSQL(sql.toString());
     }