标注

src/xiaomi/Notes-master/src/net/micode/notes/data/NotesProvider.java

@@ -34,7 +34,15 @@ import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 
-
+/**
+ *  @Package: net.micode.notes.data
+ *  @ClassName:  NotesProvider
+ *  @Description:
+ *  这个类是对ContentProvider类的扩展,功能是提供小米便签应用程序的数据,
+ *  在类当中实现了数据库的增添删减修改查找操作，并且可以处理与搜索有关的查询。
+ *  @Author: Dong Jiaqi
+ *  @CreateDate: 12/23/2023 23：27 PM
+ */
 public class NotesProvider extends ContentProvider {
     private static final UriMatcher mMatcher;
 
@@ -50,6 +58,10 @@ public class NotesProvider extends ContentProvider {
     private static final int URI_SEARCH          = 5;
     private static final int URI_SEARCH_SUGGEST  = 6;
 
+    /**
+     * 定义了一个静态代码块，初始化UriMatcher对象并且添加匹配规则
+     * 调用了addURI()方法，向mMatcher这一个UriMatcher对象中添加了一系列匹配规则
+     */
     static {
         mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
         mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
@@ -79,18 +91,36 @@ public class NotesProvider extends ContentProvider {
         + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
         + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
 
+    /**
+     * onCreate()方法的功能是在应用程序启动时进行初始化数据库帮助类
+     * @return 返回true表示创建成功
+     */
     @Override
     public boolean onCreate() {
         mHelper = NotesDatabaseHelper.getInstance(getContext());
         return true;
     }
 
+    /**
+     * query()方法用于执行查询操作,根据传入的URI参数,选择执行不同的查询语句返回
+     * @param uri 要查询数据的URI，用来确定要操作的表和行
+     * @param projection 表示查询返回的列的数组，可以指定查询结果中包含的列
+     * @param selection 表示用于筛选的条件
+     * @param selectionArgs 表示selection中的占位符的值
+     * @param sortOrder 表示查询结果的排序顺序
+     * @return 返回查询结果的游标(Cursor)对象(c)
+     */
     @Override
     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
             String sortOrder) {
         Cursor c = null;
         SQLiteDatabase db = mHelper.getReadableDatabase();
         String id = null;
+        /**
+         * 这是一个switch语句块，用来针对不同的URI进行不同的操作。
+         * 对于3种类型的URI，进行了不同的操作，如果URI不匹配这任何一种情况，就视为ILLegalArgumentException异常，表示URI不被支持或不合法
+         * 这个语句块的目的是为了处理不同类型的URI，并且根据URI类型执行相应的数据库查询操作，属于典型的Android ContentProvider的逻辑处理代码
+         */
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
                 c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
@@ -130,6 +160,11 @@ public class NotesProvider extends ContentProvider {
                     return null;
                 }
 
+                /**
+                 * 这个语句块是在处理 URI_SEARCH 和 URI_SEARCH_SUGGEST 的情况下执行的，主要功能是执行数据库的原始查询（rawQuery）操作，用于搜索符合指定条件的数据，并将结果存储在 Cursor 对象中。
+                 * 如果在执行数据库查询时发生 IllegalStateException 异常，那么异常信息会被捕获，并通过 Log.e() 方法记录下来，方便在日志中进行查看和分析。
+                 * 目的是为了在执行数据库查询时，确保搜索关键词被正确地格式化并传入查询语句中，同时也确保在出现数据库查询异常时能够进行相应的异常处理和记录。
+                 */
                 try {
                     searchString = String.format("%%%s%%", searchString);
                     c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
@@ -147,6 +182,12 @@ public class NotesProvider extends ContentProvider {
         return c;
     }
 
+    /**
+     * 用于执行插入操作，根据传入的URI参数，选择在不同的表中进行插入
+     * @param uri 传入数据的URI，用来确定要操作的表和行
+     * @param values 表示要插入的数据集合
+     * @return 返回插入数据的URI，即ContentUris.withAppendedId(uri, insertedId)
+     */
     @Override
     public Uri insert(Uri uri, ContentValues values) {
         SQLiteDatabase db = mHelper.getWritableDatabase();
@@ -181,6 +222,13 @@ public class NotesProvider extends ContentProvider {
         return ContentUris.withAppendedId(uri, insertedId);
     }
 
+    /**
+     * 执行删除操作，根据传入URI参数，选择在不同的表中执行删除操作
+     * @param uri 传入数据的URI，用来确定要操作的表和行
+     * @param selection 表示删除的条件
+     * @param selectionArgs 表示selection中的占位符的值
+     * @return 返回收到影响的内容行数
+     */
     @Override
     public int delete(Uri uri, String selection, String[] selectionArgs) {
         int count = 0;
@@ -227,12 +275,25 @@ public class NotesProvider extends ContentProvider {
         return count;
     }
 
+    /**
+     * 执行更新操作，根据传入URI参数，在不同的表中进行更新
+     * @param uri 传入数据的URI，用来确定要操作的表和行
+     * @param values 表示要更新的数据集合
+     * @param selection 表示用于筛选的条件
+     * @param selectionArgs 表示selection中的占位符的值
+     * @return 返回收到影响的行数
+     */
     @Override
     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
         int count = 0;
         String id = null;
         SQLiteDatabase db = mHelper.getWritableDatabase();
         boolean updateData = false;
+        /**
+         * 这个语句块根据传入的 URI（Uniform Resource Identifier）进行匹配，并执行相应的操作。
+         * 目的是根据传入的 URI 执行相应的数据库更新操作。根据不同的 URI，可以实现对不同表和记录的更新操作。
+         * 通过 switch-case 结构，可以清晰地处理不同的情况，并执行相应的操作，同时也提供了一个默认的处理方式来处理未知的 URI。
+         */
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
                 increaseNoteVersion(-1, selection, selectionArgs);
@@ -267,10 +328,21 @@ public class NotesProvider extends ContentProvider {
         return count;
     }
 
+    /**
+     * 用于解析查询条件，将其转换为SQL语句中的WHERE子句
+     * @param selection 表示用来解析的条件
+     * @return 返回转换后的字符串
+     */
     private String parseSelection(String selection) {
         return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
     }
 
+    /**
+     * 用于增加便签的版本号
+     * @param id 要增加版本号的便签的ID
+     * @param selection 查询选择条件，用来筛选要增加版本号的便签
+     * @param selectionArgs 表示占位符参数
+     */
     private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
         StringBuilder sql = new StringBuilder(120);
         sql.append("UPDATE ");
@@ -296,6 +368,10 @@ public class NotesProvider extends ContentProvider {
         mHelper.getWritableDatabase().execSQL(sql.toString());
     }
 
+    /**
+     * 该方法根据需要自行补充实现，给开源后其他软件工程师留下了增添空间
+     * @param uri 数据的URI
+     */
     @Override
     public String getType(Uri uri) {
         // TODO Auto-generated method stub

src/xiaomi/Notes-master/src/net/micode/notes/gtask/data/MetaData.java

@@ -24,13 +24,33 @@ import net.micode.notes.tool.GTaskStringUtils;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+/**
+ * @Package: net.micode.notes.gtask.data
+ * @ClassName:  MetaData
+ * @Description:
+ *  MetaData类继承自 Task 类。它用于处理任务的元数据信息，并封装了一些操作元数据的方法。
+ *  这个类用于管理任务的元数据信息，包括相关的 GID，在设置和获取元数据的同时，还提供了判断任务是否值得保存的方法，以及根据远程 JSON 数据设置任务内容的方法。
+ *  同时，限制了部分方法的访问，以确保其按照预期的方式被使用。
+ *  @Author: Dong Jiaqi
+ *  @CreateDate: 12/24/2023 9:53 AM
+ */
 public class MetaData extends Task {
     private final static String TAG = MetaData.class.getSimpleName();
 
     private String mRelatedGid = null;
 
+    /**
+     * 作用是将给定的 GID 和其他元数据信息添加到任务的注释信息中，并设置任务的名称为固定的值。
+     * @param gid 表示任务的全局唯一标识符（Global Task ID），是一个字符串类型的参数。
+     * @param metaInfo 表示元数据信息，是一个 JSONObject 对象，包含任务的其他相关信息。
+     */
     public void setMeta(String gid, JSONObject metaInfo) {
+        /**
+         * 这个语句块作用是向 metaInfo 这个 JSONObject 对象中添加一个键值对，其中键是 GTaskStringUtils.META_HEAD_GTASK_ID，值是变量 gid。
+         * 使用了 try-catch 块来捕获可能抛出的 JSONException 异常。
+         * 为什么要这么写呢：
+         * 因为在 Java 中，JSONObject 的 put 方法声明了可能抛出 JSONException 异常。这意味着在调用 put 方法时，需要进行异常处理，否则会导致编译错误。因此，为了保证程序的健壮性，开发者通常会在调用可能会引发异常的方法时使用 try-catch 块进行异常处理，以防止程序异常终止。
+         */
         try {
             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
         } catch (JSONException e) {
@@ -40,19 +60,29 @@ public class MetaData extends Task {
         setName(GTaskStringUtils.META_NOTE_NAME);
     }
 
+    //作用是获取任务的相关 GID，并返回其字符串形式。
     public String getRelatedGid() {
-        return mRelatedGid;
+        return mRelatedGid;//返回值是一个字符串类型的变量 mRelatedGid，表示相关 GID（Global Task ID）。mRelatedGid 是一个成员变量，它保存了在任务的元数据信息中提取出来的相关 GID。
     }
 
+    //作用是判断任务是否值得保存。它通过检查任务的注释信息是否为null来确定任务是否值得保存。
     @Override
     public boolean isWorthSaving() {
-        return getNotes() != null;
+        return getNotes() != null;//如果注释信息不为null，则返回true，表示任务值得保存；反之，如果注释信息为null，则返回false，表示任务不值得保存。
     }
 
+    /**
+     * 功能是从远程 JSON 对象中获取任务的内容，包括基本的任务属性和元数据信息，并将其存储到当前的 Task 对象中。
+     * @param js JSONObject 对象，表示从远程服务器获取的任务信息。
+     */
     @Override
     public void setContentByRemoteJSON(JSONObject js) {
         super.setContentByRemoteJSON(js);
         if (getNotes() != null) {
+            /**
+             * 这个语句块作用是从任务的注释信息中提取相关 GID，并将其保存到变量 mRelatedGid 中。
+             * 使用try-catch块是为了处理可能抛出的异常，确保程序稳定性
+             */
             try {
                 JSONObject metaInfo = new JSONObject(getNotes().trim());
                 mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
@@ -66,7 +96,7 @@ public class MetaData extends Task {
     @Override
     public void setContentByLocalJSON(JSONObject js) {
         // this function should not be called
-        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");//抛出一个IllegalAccessError异常，并且提供异常的详细描述信息
     }
 
     @Override

src/xiaomi/Notes-master/src/net/micode/notes/gtask/data/Node.java

@@ -20,24 +20,33 @@ import android.database.Cursor;
 
 import org.json.JSONObject;
 
+/**
+ * @Package: net.micode.notes.gtask.data
+ * @ClassName:  Node
+ * @Description:
+ * Node类是一个抽象类，定义了一些常量字段以及一些方法，还定义了节点对象的基本属性和操作，
+ *  * 同时提供了抽象方法来处理节点内容的设置和同步操作的创建按，以及普通方法来设置和获取节点的属性。
+ * @Author: Dong Jiaqi
+ * @CreateDate: 12/24/2023 10:23 AM
+ */
 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_ADD_LOCAL = 2;//表示本地添加操作。
 
-    public static final int SYNC_ACTION_DEL_REMOTE = 3;
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;//表示远程删除操作。
 
-    public static final int SYNC_ACTION_DEL_LOCAL = 4;
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;//表示本地删除操作。
 
-    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;//表示远程更新操作。
 
-    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;//表示本地更新操作。
 
-    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;//表示更新冲突操作。
 
-    public static final int SYNC_ACTION_ERROR = 8;
+    public static final int SYNC_ACTION_ERROR = 8;//表示同步错误操作。
 
     private String mGid;
 
@@ -66,34 +75,66 @@ public abstract class Node {
 
     public abstract int getSyncAction(Cursor c);
 
+    /**
+     * 设置节点对象的全局唯一标识符（gid）。
+     * @param gid 表示要设置的全局唯一标识符，它是一个字符串类型的参数。可以是任意有效的字符串，用于对节点进行唯一标识和区分。
+     */
     public void setGid(String gid) {
         this.mGid = gid;
     }
 
+    /**
+     * 设置节点对象的名称。它通过将传入的字符串参数 name 赋值给节点对象的成员变量 mName 来实现。
+     * @param name 表示要设置的节点名称，它是一个字符串类型的参数。可以是任意有效的字符串，用于标识节点的名称或描述。
+     */
     public void setName(String name) {
         this.mName = name;
     }
 
+    /**
+     * 设置节点对象的最后修改时间。它通过将传入的长整型参数 lastModified 赋值给节点对象的成员变量 mLastModified 来实现。
+     * @param lastModified 表示要设置的节点的最后修改时间，它是一个长整型参数，用来记录节点对象的最后修改时间
+     */
     public void setLastModified(long lastModified) {
         this.mLastModified = lastModified;
     }
 
+    /**
+     * 设置节点对象的删除状态。它通过将传入的布尔类型参数 deleted 赋值给节点对象的成员变量 mDeleted 来实现。
+     * @param deleted 表示要设置的节点的删除状态，它是一个布尔类型的参数。当该参数为 true 时，表示节点被标记为已删除；当该参数为 false 时，表示节点未被删除。
+     */
     public void setDeleted(boolean deleted) {
         this.mDeleted = deleted;
     }
 
+    /**
+     * 获取节点对象的全局唯一标识符（gid）。它通过返回节点对象的成员变量 mGid 的值来实现。
+     * @return  this.mGid表示节点的全局唯一标识符。这是一个字符串类型的返回值，用于表示节点对象的唯一标识符。
+     */
     public String getGid() {
         return this.mGid;
     }
 
+    /**
+     * 获取节点对象的名称。它通过返回节点对象的成员变量 mName 的值来实现。
+     * @return this.mName表示节点的名称。这是一个字符串类型的返回值，用于表示节点对象的名称或描述。
+     */
     public String getName() {
         return this.mName;
     }
 
+    /**
+     * 获取节点对象的最后修改时间。它通过返回节点对象的成员变量 mLastModified 的值来实现。
+     * @return this.mLastModified表示节点的最后修改时间。这是一个长整型的返回值
+     */
     public long getLastModified() {
         return this.mLastModified;
     }
 
+    /**
+     * 获取节点对象的删除状态。它通过返回节点对象的成员变量 mDeleted 的布尔值来实现。
+     * @return 表示节点的删除状态。当返回值为 true 时，表示节点已被标记为已删除；当返回值为 false 时，表示节点未被删除。
+     */
     public boolean getDeleted() {
         return this.mDeleted;
     }

src/xiaomi/Notes-master/src/net/micode/notes/gtask/data/SqlData.java

@@ -34,26 +34,33 @@ import net.micode.notes.gtask.exception.ActionFailureException;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+/**
+ * @Package: net.micode.notes.gtask.data
+ * @ClassName:  SqlData
+ * @Description:
+ * 封装了对数据库中数据的读取、更新和提交操作，可以用于管理和操作数据库中的数据。
+ * @Author: Dong Jiaqi
+ * @CreateDate: 12/24/2023 10:58 AM
+ */
 public class SqlData {
     private static final String TAG = SqlData.class.getSimpleName();
 
-    private static final int INVALID_ID = -99999;
+    private static final int INVALID_ID = -99999;//定义了一个名为 INVALID_ID 的私有静态整型常量，并赋值为 -99999，被用来表示无效的 ID 值。
 
     public static final String[] PROJECTION_DATA = new String[] {
             DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
             DataColumns.DATA3
-    };
+    };//定义了一个名为 PROJECTION_DATA 的字符串数组，其中包含了一组列名
 
-    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;
+    public static final int DATA_MIME_TYPE_COLUMN = 1;//表示数据的 MIME 类型在数据列中的索引位置，即第二列。
 
-    public static final int DATA_CONTENT_COLUMN = 2;
+    public static final int DATA_CONTENT_COLUMN = 2;//表示数据的内容在数据列中的索引位置，即第三列。
 
-    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+    public static final int DATA_CONTENT_DATA_1_COLUMN = 3;//表示数据的内容数据1在数据列中的索引位置，即第四列。
 
-    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+    public static final int DATA_CONTENT_DATA_3_COLUMN = 4;//表示数据的内容数据3在数据列中的索引位置，即第五列。
 
     private ContentResolver mContentResolver;
 
@@ -71,36 +78,54 @@ public class SqlData {
 
     private ContentValues mDiffDataValues;
 
+    /**
+     * 构造函数，接收一个Context对象作为参数，并初始化成员变量。
+     * @param context 用于获取应用程序的上下文信息，以便后续操作数据库。
+     */
     public SqlData(Context context) {
-        mContentResolver = context.getContentResolver();
+        mContentResolver = context.getContentResolver();//这是构造方法的定义，表明这是一个公共的构造方法，并且接受一个 Context 类型的参数。
         mIsCreate = true;
         mDataId = INVALID_ID;
         mDataMimeType = DataConstants.NOTE;
-        mDataContent = "";
+        mDataContent = "";//成员变量初始化
         mDataContentData1 = 0;
         mDataContentData3 = "";
-        mDiffDataValues = new ContentValues();
+        mDiffDataValues = new ContentValues();//创建新的ContentValues对象
     }
 
+    /**
+     * 构造函数，接收一个Context对象和一个Cursor对象作为参数，并根据Cursor对象加载成员变量的值。
+     * @param context 用于获取应用程序的上下文信息，以便后续操作数据库；
+     * @param c Cursor 对象用于获取数据库中的数据。
+     */
     public SqlData(Context context, Cursor c) {
         mContentResolver = context.getContentResolver();
         mIsCreate = false;
-        loadFromCursor(c);
+        loadFromCursor(c);//调用 loadFromCursor() 方法，将传入的 Cursor 对象作为参数，以从 Cursor 对象中加载数据库中的数据到 SqlData 对象的成员变量中。
         mDiffDataValues = new ContentValues();
     }
 
+    /**
+     * 从传入的 Cursor 对象中加载数据，并将数据赋值给 SqlData 对象的各个成员变量。
+     * @param c Cursor 对象用于获取数据库中的数据
+     */
     private void loadFromCursor(Cursor c) {
-        mDataId = c.getLong(DATA_ID_COLUMN);
-        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+        mDataId = c.getLong(DATA_ID_COLUMN);//从 Cursor 对象中获取指定列索引为 DATA_ID_COLUMN 的长整型数据，并赋值给 mDataId 成员变量。
+        mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);//从 Cursor 对象中获取指定列索引为 DATA_MIME_TYPE_COLUMN 的字符串数据，并赋值给 mDataMimeType 成员变量。
         mDataContent = c.getString(DATA_CONTENT_COLUMN);
         mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
         mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
     }
 
+    /**
+     * 根据传入的JSON对象设置成员变量的值。根据JSON对象中的字段值判断是否需要更新成员变量，并将需要更新的值存储在mDiffDataValues对象中。
+     * @param js JSONObject对象用于获取数据
+     * @throws JSONException 抛出的异常
+     */
     public void setContent(JSONObject js) throws JSONException {
-        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
-        if (mIsCreate || mDataId != dataId) {
-            mDiffDataValues.put(DataColumns.ID, dataId);
+        long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;//检查 JSON 对象 js 中是否包含名为 DataColumns.ID 的字段，如果包含则将其转换为 long 类型并赋给 dataId，否则将 INVALID_ID 赋给 dataId。
+        if (mIsCreate || mDataId != dataId) {//检查是否正在创建新数据（mIsCreate 为 true），或者已有数据的 dataId 是否与新获取的 dataId 不同。
+            mDiffDataValues.put(DataColumns.ID, dataId);//如果满足条件，则将 DataColumns.ID 和对应的 dataId 放入 mDiffDataValues 中。
         }
         mDataId = dataId;
 
@@ -130,42 +155,53 @@ public class SqlData {
         mDataContentData3 = dataContentData3;
     }
 
+    /**
+     * 将成员变量的值转换为JSON对象并返回。
+     * @return JSONObject 对象包含了 SqlData 对象中各个成员变量的值，使用相应的键值表示。如果当前对象是新创建的，则打印错误日志并返回 null。
+     * @throws JSONException 抛出的异常
+     */
     public JSONObject getContent() throws JSONException {
         if (mIsCreate) {
             Log.e(TAG, "it seems that we haven't created this in database yet");
             return null;
         }
         JSONObject js = new JSONObject();
-        js.put(DataColumns.ID, mDataId);
-        js.put(DataColumns.MIME_TYPE, mDataMimeType);
+        js.put(DataColumns.ID, mDataId);//将类的成员变量 mDataId 的值存储到 js 对象中，使用键名 DataColumns.ID。
+        js.put(DataColumns.MIME_TYPE, mDataMimeType);//将类的成员变量 mDataMimeType 的值存储到 js 对象中，使用键名 DataColumns.MIME_TYPE
         js.put(DataColumns.CONTENT, mDataContent);
         js.put(DataColumns.DATA1, mDataContentData1);
         js.put(DataColumns.DATA3, mDataContentData3);
         return js;
     }
 
+    /**
+     * 提交数据的更改到数据库中。如果是新创建的数据，则将数据插入数据库并获取其ID；如果是已存在的数据，则根据mDiffDataValues对象中的差异字段值更新数据库中对应的记录。
+     * @param noteId 便签的ID，表示要提交数据的便签的ID
+     * @param validateVersion 布尔值，表示是否需要验证版本号
+     * @param version 长整型数，表示版本号
+     */
     public void commit(long noteId, boolean validateVersion, long version) {
 
-        if (mIsCreate) {
+        if (mIsCreate) {//如果数据是新创建的
             if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
                 mDiffDataValues.remove(DataColumns.ID);
             }
 
-            mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
-            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
+            mDiffDataValues.put(DataColumns.NOTE_ID, noteId); //设置便签的ID
+            Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);//向数据库中插入数据
             try {
                 mDataId = Long.valueOf(uri.getPathSegments().get(1));
             } catch (NumberFormatException e) {
                 Log.e(TAG, "Get note id error :" + e.toString());
                 throw new ActionFailureException("create note failed");
             }
-        } else {
+        } else {//如果不是新创建的数据
             if (mDiffDataValues.size() > 0) {
                 int result = 0;
-                if (!validateVersion) {
+                if (!validateVersion) {//如果不用验证版本，直接更新数据
                     result = mContentResolver.update(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
-                } else {
+                } else {//如果要验证版本，根据版本号更新数据
                     result = mContentResolver.update(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
                             " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
@@ -179,10 +215,14 @@ public class SqlData {
             }
         }
 
-        mDiffDataValues.clear();
+        mDiffDataValues.clear();//提交后清空数据
         mIsCreate = false;
     }
 
+    /**
+     * 返回成员变量mDataId的值。
+     * @return 成员信息的ID
+     */
     public long getId() {
         return mDataId;
     }