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

@@ -36,20 +36,27 @@ import net.micode.notes.data.NotesDatabaseHelper.TABLE;
 
 
 public class NotesProvider extends ContentProvider {
+    // 定义一个静态的UriMatcher对象，用于匹配URI
     private static final UriMatcher mMatcher;
 
+    // 定义一个数据库帮助类对象
     private NotesDatabaseHelper mHelper;
 
+    // 定义一个日志标签
     private static final String TAG = "NotesProvider";
 
-    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;
 
-    private static final int URI_SEARCH          = 5;
-    private static final int URI_SEARCH_SUGGEST  = 6;
 
+    // 定义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; // 匹配单个数据
+
+    private static final int URI_SEARCH          = 5; // 匹配搜索
+    private static final int URI_SEARCH_SUGGEST  = 6; // 匹配搜索建议
+
+    // 静态代码块，初始化UriMatcher
     static {
         mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
         mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
@@ -80,44 +87,63 @@ public class NotesProvider extends ContentProvider {
         + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
 
     @Override
+    // 重写父类或接口中的onCreate方法
     public boolean onCreate() {
+        // 定义一个方法，返回类型为boolean，用于初始化操作
         mHelper = NotesDatabaseHelper.getInstance(getContext());
+        // 获取NotesDatabaseHelper的单例实例，并传入上下文对象
+        // NotesDatabaseHelper.getInstance()：获取单例实例的方法
+        // getContext()：获取当前上下文对象的方法
         return true;
+        // 返回true，表示初始化成功
     }
 
     @Override
     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
             String sortOrder) {
+        // 初始化游标对象
         Cursor c = null;
+        // 获取可读数据库实例
         SQLiteDatabase db = mHelper.getReadableDatabase();
+        // 初始化ID变量
         String id = null;
+        // 根据URI匹配不同的查询类型
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
+                // 查询NOTE表
                 c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
             case URI_NOTE_ITEM:
+                // 获取NOTE表中的特定ID
                 id = uri.getPathSegments().get(1);
+                // 查询NOTE表中ID匹配的记录
                 c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs, null, null, sortOrder);
                 break;
             case URI_DATA:
+                // 查询DATA表
                 c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
                         sortOrder);
                 break;
             case URI_DATA_ITEM:
+                // 获取DATA表中的特定ID
                 id = uri.getPathSegments().get(1);
+                // 查询DATA表中ID匹配的记录
                 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");
                 }
 
+                // 初始化搜索字符串
                 String searchString = null;
+                // 根据URI类型获取搜索字符串
                 if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
                     if (uri.getPathSegments().size() > 1) {
                         searchString = uri.getPathSegments().get(1);
@@ -126,44 +152,60 @@ public class NotesProvider extends ContentProvider {
                     searchString = uri.getQueryParameter("pattern");
                 }
 
+                // 如果搜索字符串为空，返回null
                 if (TextUtils.isEmpty(searchString)) {
                     return null;
                 }
 
                 try {
+                    // 格式化搜索字符串
                     searchString = String.format("%%%s%%", searchString);
+                    // 执行原生SQL查询
                     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)) {
             case URI_NOTE:
+                // 插入到NOTE表，并获取插入的ID
                 insertedId = noteId = db.insert(TABLE.NOTE, null, values);
                 break;
             case URI_DATA:
+                // 检查插入的值是否包含NOTE_ID
                 if (values.containsKey(DataColumns.NOTE_ID)) {
+                    // 获取NOTE_ID
                     noteId = values.getAsLong(DataColumns.NOTE_ID);
                 } else {
+                    // 如果没有NOTE_ID，记录错误日志
                     Log.d(TAG, "Wrong data format without note id:" + values.toString());
                 }
+                // 插入到DATA表，并获取插入的ID
                 insertedId = dataId = db.insert(TABLE.DATA, null, values);
                 break;
             default:
+                // 如果URI不匹配，抛出异常
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
         // Notify the note uri
@@ -183,25 +225,31 @@ public class NotesProvider extends ContentProvider {
 
     @Override
     public int delete(Uri uri, String selection, String[] selectionArgs) {
+        // 初始化删除的记录数为0
         int count = 0;
+        // 初始化记录ID为null
         String id = null;
+        // 获取可写数据库实例
         SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 初始化是否删除数据的标志为false
         boolean deleteData = false;
+        // 根据URI匹配不同的操作类型
         switch (mMatcher.match(uri)) {
             case URI_NOTE:
+                // 为查询条件添加额外的限制：ID大于0
                 selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
+                // 执行删除操作并获取删除的记录数
                 count = db.delete(TABLE.NOTE, selection, selectionArgs);
                 break;
             case URI_NOTE_ITEM:
+                // 从URI中获取具体的记录ID
                 id = uri.getPathSegments().get(1);
-                /**
-                 * ID that smaller than 0 is system folder which is not allowed to
-                 * trash
-                 */
+                // 执行删除操作并获取删除的记录数
                 long noteId = Long.valueOf(id);
                 if (noteId <= 0) {
                     break;
                 }
+
                 count = db.delete(TABLE.NOTE,
                         NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
                 break;
@@ -220,8 +268,10 @@ public class NotesProvider extends ContentProvider {
         }
         if (count > 0) {
             if (deleteData) {
+                // 如果删除的是数据，通知内容解析器数据已更改
                 getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
             }
+            // 通知内容解析器指定URI的数据已更改
             getContext().getContentResolver().notifyChange(uri, null);
         }
         return count;
@@ -229,70 +279,107 @@ public class NotesProvider extends ContentProvider {
 
     @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:
+                // 增加笔记版本号，-1表示更新所有笔记
                 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);
+                // 更新指定ID的笔记记录
                 count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs);
                 break;
             case URI_DATA:
+                // 更新数据表中的记录
                 count = db.update(TABLE.DATA, values, selection, selectionArgs);
+                // 设置更新数据标记为true
                 updateData = true;
                 break;
             case URI_DATA_ITEM:
+                // 获取URI中的数据ID
                 id = uri.getPathSegments().get(1);
+                // 更新指定ID的数据记录
                 count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
                         + parseSelection(selection), selectionArgs);
+                // 设置更新数据标记为true
                 updateData = true;
                 break;
             default:
+                // 如果URI不匹配，抛出非法参数异常
                 throw new IllegalArgumentException("Unknown URI " + uri);
         }
 
+        // 如果有记录被更新
         if (count > 0) {
+            // 如果更新了数据表，通知内容解析器数据已更改
             if (updateData) {
                 getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
             }
+            // 通知内容解析器指定URI的数据已更改
             getContext().getContentResolver().notifyChange(uri, null);
         }
+        // 返回更新的记录数
         return count;
     }
 
+    // 定义一个私有方法parseSelection，用于解析传入的选择条件字符串
     private String parseSelection(String selection) {
+        // 使用三元运算符判断传入的选择条件字符串是否为空或仅包含空白字符
+        // TextUtils.isEmpty(selection)用于检查字符串是否为空或仅包含空白字符
+        // 如果selection不为空且不全是空白字符，则返回" AND (" + selection + ')'
+        // 其中" AND ("和")"用于将传入的选择条件包裹起来，以便在SQL查询中使用
+        // 如果selection为空或仅包含空白字符，则返回空字符串
         return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
     }
 
+    // 增加笔记版本号的方法
     private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+        // 创建一个StringBuilder对象，用于构建SQL语句，初始容量为120
         StringBuilder sql = new StringBuilder(120);
+        // 添加UPDATE语句和表名
         sql.append("UPDATE ");
         sql.append(TABLE.NOTE);
         sql.append(" SET ");
+        // 设置版本号字段自增1
         sql.append(NoteColumns.VERSION);
         sql.append("=" + NoteColumns.VERSION + "+1 ");
 
+        // 如果id大于0或者selection不为空，则添加WHERE子句
         if (id > 0 || !TextUtils.isEmpty(selection)) {
             sql.append(" WHERE ");
         }
+        // 如果id大于0，则添加id的过滤条件
         if (id > 0) {
             sql.append(NoteColumns.ID + "=" + String.valueOf(id));
         }
+        // 如果selection不为空，则处理selection字符串
         if (!TextUtils.isEmpty(selection)) {
+            // 如果id大于0，则对selection进行解析
             String selectString = id > 0 ? parseSelection(selection) : selection;
+            // 遍历selectionArgs数组，将selectString中的占位符替换为实际的参数值
             for (String args : selectionArgs) {
                 selectString = selectString.replaceFirst("\\?", args);
             }
+            // 将处理后的selectString添加到SQL语句中
             sql.append(selectString);
         }
 
+        // 获取可写的数据库实例，并执行构建好的SQL语句
         mHelper.getWritableDatabase().execSQL(sql.toString());
     }
 

src/note_but_github/app/src/main/java/net/micode/notes/gtask/data/MetaData.java

@@ -26,43 +26,61 @@ import org.json.JSONObject;
 
 
 public class MetaData extends Task {
+    // 定义一个静态常量TAG，用于日志输出，值为当前类的简单名称
     private final static String TAG = MetaData.class.getSimpleName();
 
+    // 定义一个私有成员变量mRelatedGid，用于存储相关的GID
     private String mRelatedGid = null;
 
+    // 设置元数据的方法，接收一个GID和一个JSONObject类型的metaInfo
     public void setMeta(String gid, JSONObject metaInfo) {
         try {
+            // 将GID放入metaInfo的META_HEAD_GTASK_ID键中
             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
         } catch (JSONException e) {
+            // 如果放入失败，输出错误日志
             Log.e(TAG, "failed to put related gid");
         }
+        // 将metaInfo转换为字符串并设置为任务的笔记
         setNotes(metaInfo.toString());
+        // 设置任务的名称为META_NOTE_NAME
         setName(GTaskStringUtils.META_NOTE_NAME);
     }
 
+    // 获取相关GID的方法
     public String getRelatedGid() {
         return mRelatedGid;
     }
 
+    // 重写isWorthSaving方法，判断任务是否值得保存
     @Override
     public boolean isWorthSaving() {
+        // 如果笔记不为空，则返回true
         return getNotes() != null;
     }
 
+    // 重写setContentByRemoteJSON方法，根据远程JSON设置内容
     @Override
     public void setContentByRemoteJSON(JSONObject js) {
+        // 调用父类的setContentByRemoteJSON方法
         super.setContentByRemoteJSON(js);
+        // 如果笔记不为空
         if (getNotes() != null) {
             try {
+                // 将笔记转换为JSONObject
                 JSONObject metaInfo = new JSONObject(getNotes().trim());
+                // 从metaInfo中获取META_HEAD_GTASK_ID的值并赋给mRelatedGid
                 mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
             } catch (JSONException e) {
+                // 如果转换失败，输出警告日志
                 Log.w(TAG, "failed to get related gid");
+                // 将mRelatedGid设置为null
                 mRelatedGid = null;
             }
         }
     }
 
+    // 重写setContentByLocalJSON方法，该方法不应被调用
     @Override
     public void setContentByLocalJSON(JSONObject js) {
         // this function should not be called

src/note_but_github/app/src/main/java/net/micode/notes/gtask/data/Node.java

@@ -20,80 +20,109 @@ import android.database.Cursor;
 
 import org.json.JSONObject;
 
+// 定义一个抽象类 Node，用于表示节点的基本属性和行为
 public abstract class Node {
+    // 定义同步操作的常量，表示无操作
     public static final int SYNC_ACTION_NONE = 0;
 
+    // 定义同步操作的常量，表示添加远程节点
     public static final int SYNC_ACTION_ADD_REMOTE = 1;
 
+    // 定义同步操作的常量，表示添加本地节点
     public static final int SYNC_ACTION_ADD_LOCAL = 2;
 
+    // 定义同步操作的常量，表示删除远程节点
     public static final int SYNC_ACTION_DEL_REMOTE = 3;
 
+    // 定义同步操作的常量，表示删除本地节点
     public static final int SYNC_ACTION_DEL_LOCAL = 4;
 
+    // 定义同步操作的常量，表示更新远程节点
     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_CONFLICT = 7;
 
+    // 定义同步操作的常量，表示错误
     public static final int SYNC_ACTION_ERROR = 8;
 
+    // 私有成员变量，表示节点的全局唯一标识符
     private String mGid;
 
+    // 私有成员变量，表示节点的名称
     private String mName;
 
+    // 私有成员变量，表示节点的最后修改时间
     private long mLastModified;
 
+    // 私有成员变量，表示节点是否被删除
     private boolean mDeleted;
 
+    // 构造函数，初始化节点的基本属性
     public Node() {
-        mGid = null;
-        mName = "";
-        mLastModified = 0;
-        mDeleted = false;
+        mGid = null; // 初始化全局唯一标识符为空
+        mName = ""; // 初始化名称为空字符串
+        mLastModified = 0; // 初始化最后修改时间为0
+        mDeleted = false; // 初始化删除状态为未删除
     }
 
+    // 抽象方法，用于获取创建操作的JSON对象
     public abstract JSONObject getCreateAction(int actionId);
 
+    // 抽象方法，用于获取更新操作的JSON对象
     public abstract JSONObject getUpdateAction(int actionId);
 
+    // 抽象方法，根据远程JSON对象设置节点内容
     public abstract void setContentByRemoteJSON(JSONObject js);
 
+    // 抽象方法，根据本地JSON对象设置节点内容
     public abstract void setContentByLocalJSON(JSONObject js);
 
+    // 抽象方法，从节点内容获取本地JSON对象
     public abstract JSONObject getLocalJSONFromContent();
 
+    // 抽象方法，根据游标获取同步操作类型
     public abstract int getSyncAction(Cursor c);
 
+    // 设置节点的全局唯一标识符
     public void setGid(String gid) {
         this.mGid = gid;
     }
 
+    // 设置节点的名称
     public void setName(String name) {
         this.mName = name;
     }
 
+    // 设置节点的最后修改时间
     public void setLastModified(long lastModified) {
         this.mLastModified = lastModified;
     }
 
+    // 设置节点的删除状态
     public void setDeleted(boolean deleted) {
         this.mDeleted = deleted;
     }
 
+    // 获取节点的全局唯一标识符
     public String getGid() {
         return this.mGid;
     }
 
+    // 获取节点的名称
     public String getName() {
         return this.mName;
     }
 
+    // 获取节点的最后修改时间
     public long getLastModified() {
         return this.mLastModified;
     }
 
+    // 获取节点的删除状态
     public boolean getDeleted() {
         return this.mDeleted;
     }

src/note_but_github/app/src/main/java/net/micode/notes/gtask/data/SqlData.java

@@ -36,15 +36,19 @@ import org.json.JSONObject;
 
 
 public class SqlData {
+    // 定义日志标签，用于日志输出
     private static final String TAG = SqlData.class.getSimpleName();
 
+    // 定义无效ID常量
     private static final int INVALID_ID = -99999;
 
+    // 定义查询数据时使用的列名数组
     public static final String[] PROJECTION_DATA = new String[] {
             DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
             DataColumns.DATA3
     };
 
+    // 定义各列在PROJECTION_DATA数组中的索引
     public static final int DATA_ID_COLUMN = 0;
 
     public static final int DATA_MIME_TYPE_COLUMN = 1;
@@ -55,20 +59,28 @@ public class SqlData {
 
     public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
 
+    // 内容解析器，用于操作数据库
     private ContentResolver mContentResolver;
 
+    // 标记是否为创建操作
     private boolean mIsCreate;
 
+    // 数据ID
     private long mDataId;
 
+    // 数据的MIME类型
     private String mDataMimeType;
 
+    // 数据内容
     private String mDataContent;
 
+    // 数据内容中的第一个附加数据
     private long mDataContentData1;
 
+    // 数据内容中的第三个附加数据
     private String mDataContentData3;
 
+    // 存储与原始数据不同的数据值
     private ContentValues mDiffDataValues;
 
     // 构造函数，用于初始化SqlData对象
@@ -83,6 +95,7 @@ public class SqlData {
         mDiffDataValues = new ContentValues();
     }
 
+    // 构造函数，用于从Cursor对象中加载数据
     public SqlData(Context context, Cursor c) {
         mContentResolver = context.getContentResolver();
         mIsCreate = false;
@@ -104,6 +117,7 @@ public class SqlData {
         mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
     }
 
+    // 设置数据内容，根据传入的JSONObject更新成员变量和差异数据值
     public void setContent(JSONObject js) throws JSONException {
         long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
         if (mIsCreate || mDataId != dataId) {
@@ -137,6 +151,7 @@ public class SqlData {
         mDataContentData3 = dataContentData3;
     }
 
+    // 获取数据内容的JSONObject表示
     public JSONObject getContent() throws JSONException {
         if (mIsCreate) {
             Log.e(TAG, "it seems that we haven't created this in database yet");
@@ -151,6 +166,7 @@ public class SqlData {
         return js;
     }
 
+    // 提交数据到数据库
     public void commit(long noteId, boolean validateVersion, long version) {
 
         // 检查是否是创建新笔记的操作
@@ -203,6 +219,7 @@ public class SqlData {
         mIsCreate = false;
     }
 
+    // 获取ID
     public long getId() {
         return mDataId;
     }

src/note_but_github/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java

@@ -39,10 +39,13 @@ import java.util.ArrayList;
 
 
 public class SqlNote {
+    // 定义日志标签，用于日志输出
     private static final String TAG = SqlNote.class.getSimpleName();
 
+    // 定义无效ID常量
     private static final int INVALID_ID = -99999;
 
+    // 定义查询笔记的列名数组
     public static final String[] PROJECTION_NOTE = new String[] {
             NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
             NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@@ -52,6 +55,7 @@ public class SqlNote {
             NoteColumns.VERSION
     };
 
+    // 定义各列在PROJECTION_NOTE数组中的索引
     public static final int ID_COLUMN = 0;
 
     public static final int ALERTED_DATE_COLUMN = 1;
@@ -86,24 +90,34 @@ public class SqlNote {
 
     public static final int VERSION_COLUMN = 16;
 
+    // 定义上下文对象
     private Context mContext;
 
+    // 定义内容解析器对象
     private ContentResolver mContentResolver;
 
+    // 定义是否为新创建的笔记
     private boolean mIsCreate;
 
+    // 定义笔记的ID
     private long mId;
 
+    // 定义笔记的提醒日期
     private long mAlertDate;
 
+    // 定义笔记的背景颜色ID
     private int mBgColorId;
 
+    // 定义笔记的创建日期
     private long mCreatedDate;
 
+    // 定义笔记是否有附件
     private int mHasAttachment;
 
+    // 定义笔记的最后修改日期
     private long mModifiedDate;
 
+    // 定义笔记的父级ID
     private long mParentId;
 
     private String mSnippet;

src/note_but_github/app/src/main/java/net/micode/notes/gtask/exception/ActionFailureException.java

@@ -16,17 +16,22 @@
 
 package net.micode.notes.gtask.exception;
 
+// 定义一个名为ActionFailureException的异常类，继承自RuntimeException
 public class ActionFailureException extends RuntimeException {
+    // 定义一个序列化版本UID，用于序列化和反序列化时保持类的兼容性
     private static final long serialVersionUID = 4425249765923293627L;
 
+    // 无参构造方法，调用父类的无参构造方法
     public ActionFailureException() {
         super();
     }
 
+    // 带有一个字符串参数的构造方法，用于传递异常信息，调用父类的带字符串参数的构造方法
     public ActionFailureException(String paramString) {
         super(paramString);
     }
 
+    // 带有一个字符串参数和一个Throwable参数的构造方法，用于传递异常信息和原始异常，调用父类的带字符串和Throwable参数的构造方法
     public ActionFailureException(String paramString, Throwable paramThrowable) {
         super(paramString, paramThrowable);
     }

src/note_but_github/app/src/main/java/net/micode/notes/gtask/exception/NetworkFailureException.java

@@ -16,17 +16,22 @@
 
 package net.micode.notes.gtask.exception;
 
+// 定义一个名为 NetworkFailureException 的异常类，继承自 Exception 类
 public class NetworkFailureException extends Exception {
+    // 定义一个序列化版本UID，用于序列化和反序列化时保持类的兼容性
     private static final long serialVersionUID = 2107610287180234136L;
 
+    // 无参构造函数，调用父类的无参构造函数
     public NetworkFailureException() {
         super();
     }
 
+    // 带有一个字符串参数的构造函数，用于传递异常信息，调用父类的带字符串参数的构造函数
     public NetworkFailureException(String paramString) {
         super(paramString);
     }
 
+    // 带有一个字符串参数和一个 Throwable 参数的构造函数，用于传递异常信息和原始异常对象，调用父类的带这两个参数的构造函数
     public NetworkFailureException(String paramString, Throwable paramThrowable) {
         super(paramString, paramThrowable);
     }

src/note_but_github/app/src/main/java/net/micode/notes/tool/BackupUtils.java

@@ -41,10 +41,19 @@ public class BackupUtils {
     // Singleton stuff
     private static BackupUtils sInstance;
 
+    /**
+     * 获取BackupUtils的单例实例
+     * @param context 上下文对象
+     * @return BackupUtils实例
+     */
+    // 定义一个公共的静态同步方法，用于获取BackupUtils的单例实例
     public static synchronized BackupUtils getInstance(Context context) {
+        // 检查当前单例实例是否为空
         if (sInstance == null) {
+            // 如果为空，则创建一个新的BackupUtils实例，传入上下文参数
             sInstance = new BackupUtils(context);
         }
+        // 返回BackupUtils的单例实例
         return sInstance;
     }
 
@@ -65,49 +74,67 @@ public class BackupUtils {
 
     private TextExport mTextExport;
 
+    // 定义一个私有的构造方法，用于创建BackupUtils类的实例
     private BackupUtils(Context context) {
+        // 创建一个TextExport对象，并将传入的上下文对象context作为参数传递给TextExport的构造方法
         mTextExport = new TextExport(context);
     }
 
+    // 定义一个私有静态方法，用于检查外部存储是否可用
     private static boolean externalStorageAvailable() {
+        // 调用Environment类的getExternalStorageState()方法获取外部存储的状态
+        // 将获取到的状态与Environment.MEDIA_MOUNTED常量进行比较
+        // 如果状态为MEDIA_MOUNTED，则表示外部存储已挂载且可用，返回true
+        // 否则返回false
         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
     }
 
+    // 定义一个名为exportToText的方法，该方法返回一个整型值
     public int exportToText() {
+        // 调用mTextExport对象的exportToText方法，并将返回值作为当前方法的返回值
         return mTextExport.exportToText();
     }
 
+    // 定义一个公共的方法，用于获取导出的文本文件名
     public String getExportedTextFileName() {
+        // 返回mTextExport对象的mFileName属性，即导出的文本文件名
         return mTextExport.mFileName;
     }
 
+    // 定义一个公共方法，用于获取导出的文本文件目录
     public String getExportedTextFileDir() {
+        // 返回mTextExport对象的mFileDirectory属性值，即导出的文本文件目录
         return mTextExport.mFileDirectory;
     }
 
+    // 定义一个静态内部类 TextExport，用于将笔记导出为文本
     private static class TextExport {
+        // 定义查询笔记时所需的列
         private static final String[] NOTE_PROJECTION = {
-                NoteColumns.ID,
-                NoteColumns.MODIFIED_DATE,
-                NoteColumns.SNIPPET,
-                NoteColumns.TYPE
+                NoteColumns.ID, // 笔记ID
+                NoteColumns.MODIFIED_DATE, // 笔记修改日期
+                NoteColumns.SNIPPET, // 笔记摘要
+                NoteColumns.TYPE // 笔记类型
         };
 
+        // 定义笔记列的索引常量
         private static final int NOTE_COLUMN_ID = 0;
 
         private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
 
         private static final int NOTE_COLUMN_SNIPPET = 2;
 
+        // 定义查询数据时所需的列
         private static final String[] DATA_PROJECTION = {
-                DataColumns.CONTENT,
-                DataColumns.MIME_TYPE,
-                DataColumns.DATA1,
-                DataColumns.DATA2,
-                DataColumns.DATA3,
-                DataColumns.DATA4,
+                DataColumns.CONTENT, // 数据内容
+                DataColumns.MIME_TYPE, // 数据MIME类型
+                DataColumns.DATA1, // 数据1
+                DataColumns.DATA2, // 数据2
+                DataColumns.DATA3, // 数据3
+                DataColumns.DATA4, // 数据4
         };
 
+        // 定义数据列的索引常量
         private static final int DATA_COLUMN_CONTENT = 0;
 
         private static final int DATA_COLUMN_MIME_TYPE = 1;
@@ -116,15 +143,18 @@ public class BackupUtils {
 
         private static final int DATA_COLUMN_PHONE_NUMBER = 4;
 
+        // 定义文本格式数组
         private final String [] TEXT_FORMAT;
-        private static final int FORMAT_FOLDER_NAME          = 0;
-        private static final int FORMAT_NOTE_DATE            = 1;
-        private static final int FORMAT_NOTE_CONTENT         = 2;
+        private static final int FORMAT_FOLDER_NAME          = 0; // 文件夹名称格式
+        private static final int FORMAT_NOTE_DATE            = 1; // 笔记日期格式
+        private static final int FORMAT_NOTE_CONTENT         = 2; // 笔记内容格式
 
+        // 定义上下文对象和文件名、文件目录
         private Context mContext;
         private String mFileName;
         private String mFileDirectory;
 
+        // 构造函数，初始化上下文和文本格式数组
         public TextExport(Context context) {
             TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
             mContext = context;
@@ -132,6 +162,7 @@ public class BackupUtils {
             mFileDirectory = "";
         }
 
+        // 根据格式ID获取对应的格式字符串
         private String getFormat(int id) {
             return TEXT_FORMAT[id];
         }
@@ -139,6 +170,8 @@ public class BackupUtils {
         /**
          * Export the folder identified by folder id to text
          */
+
+        // 定义一个私有方法，用于将指定文件夹中的笔记导出为文本
         private void exportFolderToText(String folderId, PrintStream ps) {
             // Query notes belong to this folder
             Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
@@ -165,6 +198,7 @@ public class BackupUtils {
         /**
          * Export note identified by id to a print stream
          */
+        // 导出笔记到文本文件
         private void exportNoteToText(String noteId, PrintStream ps) {
             Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
                     DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
@@ -218,16 +252,19 @@ public class BackupUtils {
         /**
          * Note will be exported as text which is user readable
          */
+        // 导出数据到文本文件的方法
         public int exportToText() {
+            // 检查外部存储是否可用
             if (!externalStorageAvailable()) {
-                Log.d(TAG, "Media was not mounted");
-                return STATE_SD_CARD_UNMOUONTED;
+                Log.d(TAG, "Media was not mounted"); // 日志记录：媒体未挂载
+                return STATE_SD_CARD_UNMOUONTED; // 返回状态：SD卡未挂载
             }
 
+            // 获取用于导出文本的PrintStream对象
             PrintStream ps = getExportToTextPrintStream();
             if (ps == null) {
-                Log.e(TAG, "get print stream error");
-                return STATE_SYSTEM_ERROR;
+                Log.e(TAG, "get print stream error"); // 日志记录：获取打印流错误
+                return STATE_SYSTEM_ERROR; // 返回状态：系统错误
             }
             // First export folder and its notes
             Cursor folderCursor = mContext.getContentResolver().query(
@@ -285,26 +322,41 @@ public class BackupUtils {
         /**
          * Get a print stream pointed to the file {@generateExportedTextFile}
          */
+        // 定义一个私有方法，用于获取用于导出文本的PrintStream对象
         private PrintStream getExportToTextPrintStream() {
+            // 调用generateFileMountedOnSDcard方法生成一个文件对象，文件保存在SD卡的指定路径和名称
             File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
                     R.string.file_name_txt_format);
+            // 检查文件对象是否为空，如果为空则表示文件创建失败
             if (file == null) {
+                // 使用Log.e输出错误信息，TAG为日志标签，"create file to exported failed"为错误信息
                 Log.e(TAG, "create file to exported failed");
+                // 返回null表示获取PrintStream对象失败
                 return null;
             }
+            // 获取文件名并赋值给mFileName变量
             mFileName = file.getName();
+            // 获取文件路径并赋值给mFileDirectory变量
             mFileDirectory = mContext.getString(R.string.file_path);
+            // 初始化PrintStream对象为null
             PrintStream ps = null;
             try {
+                // 创建FileOutputStream对象，用于写入文件
                 FileOutputStream fos = new FileOutputStream(file);
+                // 创建PrintStream对象，将FileOutputStream对象作为参数传入
                 ps = new PrintStream(fos);
             } catch (FileNotFoundException e) {
+                // 捕获文件未找到异常，并打印堆栈跟踪信息
                 e.printStackTrace();
+                // 返回null表示获取PrintStream对象失败
                 return null;
             } catch (NullPointerException e) {
+                // 捕获空指针异常，并打印堆栈跟踪信息
                 e.printStackTrace();
+                // 返回null表示获取PrintStream对象失败
                 return null;
             }
+            // 返回创建的PrintStream对象
             return ps;
         }
     }
@@ -312,31 +364,44 @@ public class BackupUtils {
     /**
      * Generate the text file to store imported data
      */
+    // 定义一个私有静态方法，用于在SD卡上生成文件
     private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+        // 创建一个StringBuilder对象，用于构建文件路径
         StringBuilder sb = new StringBuilder();
+        // 将SD卡根目录追加到StringBuilder中
         sb.append(Environment.getExternalStorageDirectory());
+        // 将资源ID对应的文件路径字符串追加到StringBuilder中
         sb.append(context.getString(filePathResId));
+        // 根据构建的路径字符串创建一个File对象，表示文件目录
         File filedir = new File(sb.toString());
+        // 将资源ID对应的文件名格式字符串和当前日期格式化后追加到StringBuilder中
         sb.append(context.getString(
                 fileNameFormatResId,
                 DateFormat.format(context.getString(R.string.format_date_ymd),
                         System.currentTimeMillis())));
+        // 根据构建的完整路径字符串创建一个File对象，表示文件
         File file = new File(sb.toString());
 
         try {
+            // 如果文件目录不存在，则创建目录
             if (!filedir.exists()) {
                 filedir.mkdir();
             }
+            // 如果文件不存在，则创建文件
             if (!file.exists()) {
                 file.createNewFile();
             }
+            // 返回创建的文件对象
             return file;
         } catch (SecurityException e) {
+            // 捕获安全异常并打印堆栈跟踪
             e.printStackTrace();
         } catch (IOException e) {
+            // 捕获IO异常并打印堆栈跟踪
             e.printStackTrace();
         }
 
+        // 如果发生异常，返回null
         return null;
     }
 }

src/note_but_github/app/src/main/java/net/micode/notes/tool/DataUtils.java

@@ -37,83 +37,127 @@ import java.util.HashSet;
 
 public class DataUtils {
     public static final String TAG = "DataUtils";
+    // 定义一个静态方法，用于批量删除笔记
     public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+        // 检查传入的ID集合是否为空
         if (ids == null) {
+            // 如果ID集合为空，记录调试日志并返回true
             Log.d(TAG, "the ids is null");
             return true;
         }
+        // 检查ID集合是否为空
         if (ids.size() == 0) {
+            // 如果ID集合为空，记录调试日志并返回true
             Log.d(TAG, "no id is in the hashset");
             return true;
         }
 
+        // 创建一个操作列表，用于存储删除操作
         ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        // 遍历ID集合
         for (long id : ids) {
+            // 检查当前ID是否为系统文件夹根ID
             if(id == Notes.ID_ROOT_FOLDER) {
+                // 如果是系统文件夹根ID，记录错误日志并跳过当前循环
                 Log.e(TAG, "Don't delete system folder root");
                 continue;
             }
+            // 创建一个删除操作的构建器，指定要删除的笔记URI
             ContentProviderOperation.Builder builder = ContentProviderOperation
                     .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            // 将构建的删除操作添加到操作列表中
             operationList.add(builder.build());
         }
         try {
+            // 使用ContentResolver批量应用操作列表中的操作
             ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 检查操作结果是否为空或长度为0，或者第一个元素是否为空
             if (results == null || results.length == 0 || results[0] == null) {
+                // 如果操作结果为空，记录调试日志并返回false
                 Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                 return false;
             }
+            // 如果操作成功，返回true
             return true;
         } catch (RemoteException e) {
+            // 捕获远程异常，记录错误日志
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         } catch (OperationApplicationException e) {
+            // 捕获操作应用异常，记录错误日志
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         }
+        // 如果发生异常，返回false
         return false;
     }
 
+    // 定义一个静态方法，用于将指定的笔记移动到目标文件夹
     public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+        // 创建一个ContentValues对象，用于存储要更新的数据
         ContentValues values = new ContentValues();
+        // 将目标文件夹ID放入ContentValues对象中，键为NoteColumns.PARENT_ID
         values.put(NoteColumns.PARENT_ID, desFolderId);
+        // 将源文件夹ID放入ContentValues对象中，键为NoteColumns.ORIGIN_PARENT_ID
         values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
+        // 将本地修改标志设置为1，表示该笔记已被本地修改，键为NoteColumns.LOCAL_MODIFIED
         values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        // 使用ContentResolver的update方法更新数据库中的笔记
+        // ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)生成包含笔记ID的URI
+        // values为要更新的数据，null和null为更新条件，此处表示更新所有匹配的记录
         resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
     }
 
+    // 定义一个静态方法，用于将一组笔记批量移动到指定文件夹
     public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
             long folderId) {
+        // 检查传入的ID集合是否为空
         if (ids == null) {
+            // 如果为空，记录日志并返回true（表示没有需要移动的笔记）
             Log.d(TAG, "the ids is null");
             return true;
         }
 
+        // 创建一个用于存储ContentProvider操作的列表
         ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        // 遍历ID集合
         for (long id : ids) {
+            // 创建一个ContentProviderOperation的构建器，用于更新指定ID的笔记
             ContentProviderOperation.Builder builder = ContentProviderOperation
                     .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            // 设置笔记的新父文件夹ID
             builder.withValue(NoteColumns.PARENT_ID, folderId);
+            // 设置笔记的本地修改标志为1，表示已修改
             builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
+            // 将构建好的操作添加到操作列表中
             operationList.add(builder.build());
         }
 
+        // 尝试执行批量操作
         try {
+            // 使用ContentResolver的applyBatch方法执行操作列表
             ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 检查操作结果是否为空或无效
             if (results == null || results.length == 0 || results[0] == null) {
+                // 如果操作失败，记录日志并返回false
                 Log.d(TAG, "delete notes failed, ids:" + ids.toString());
                 return false;
             }
+            // 如果操作成功，返回true
             return true;
         } catch (RemoteException e) {
+            // 捕获远程异常并记录错误日志
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         } catch (OperationApplicationException e) {
+            // 捕获操作应用异常并记录错误日志
             Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
         }
+        // 如果出现异常，返回false表示操作失败
         return false;
     }
 
     /**
      * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
      */
+    // 定义一个静态方法，用于获取用户文件夹的数量
     public static int getUserFolderCount(ContentResolver resolver) {
         Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
                 new String[] { "COUNT(*)" },
@@ -153,21 +197,32 @@ public class DataUtils {
         return exist;
     }
 
+    // 定义一个静态方法，用于检查指定ID的笔记是否存在于数据库中
     public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+        // 使用ContentResolver查询数据库，获取指定ID的笔记
+        // ContentUris.withAppendedId方法将noteId附加到CONTENT_NOTE_URI上，形成完整的URI
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
                 null, null, null, null);
 
+        // 初始化一个布尔变量，用于表示笔记是否存在
         boolean exist = false;
+        // 检查查询结果是否为空
         if (cursor != null) {
+            // 如果查询结果不为空，检查结果集的大小
             if (cursor.getCount() > 0) {
+                // 如果结果集大小大于0，表示笔记存在，将exist设置为true
                 exist = true;
             }
+            // 关闭Cursor，释放资源
             cursor.close();
         }
+        // 返回笔记是否存在的结果
         return exist;
     }
 
+    // 定义一个静态方法，用于检查指定ID的数据是否存在于数据数据库中
     public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+        // 使用ContentResolver查询数据，构建查询的URI，将dataId附加到Notes.CONTENT_DATA_URI后面
         Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
                 null, null, null, null);
 
@@ -181,6 +236,7 @@ public class DataUtils {
         return exist;
     }
 
+    // 定义一个静态方法checkVisibleFolderName，用于检查指定名称的文件夹是否可见
     public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
                 NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
@@ -197,73 +253,116 @@ public class DataUtils {
         return exist;
     }
 
+    // 定义一个静态方法，用于获取指定文件夹下的便签小部件属性集合
     public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+        // 使用ContentResolver查询笔记内容URI，获取指定文件夹ID下的笔记小部件信息
         Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
+                // 查询的列：小部件ID和小部件类型
                 new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
+                // 查询条件：父ID等于指定的文件夹ID
                 NoteColumns.PARENT_ID + "=?",
+                // 查询条件参数：文件夹ID的字符串形式
                 new String[] { String.valueOf(folderId) },
+                // 排序方式：无特定排序
                 null);
 
+        // 初始化一个HashSet用于存储小部件属性
         HashSet<AppWidgetAttribute> set = null;
+        // 检查查询结果是否为空
         if (c != null) {
+            // 检查查询结果是否有数据
             if (c.moveToFirst()) {
+                // 初始化HashSet
                 set = new HashSet<AppWidgetAttribute>();
+                // 遍历查询结果
                 do {
                     try {
+                        // 创建一个新的AppWidgetAttribute对象
                         AppWidgetAttribute widget = new AppWidgetAttribute();
+                        // 从Cursor中获取小部件ID并赋值给widget对象
                         widget.widgetId = c.getInt(0);
+                        // 从Cursor中获取小部件类型并赋值给widget对象
                         widget.widgetType = c.getInt(1);
+                        // 将widget对象添加到HashSet中
                         set.add(widget);
                     } catch (IndexOutOfBoundsException e) {
+                        // 捕获并记录数组越界异常
                         Log.e(TAG, e.toString());
                     }
-                } while (c.moveToNext());
+                } while (c.moveToNext()); // 移动到下一行数据
             }
+            // 关闭Cursor
             c.close();
         }
+        // 返回小部件属性集合
         return set;
     }
 
+    // 定义一个静态方法，用于通过笔记ID获取电话号码
     public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+        // 使用ContentResolver查询笔记内容URI，获取电话号码
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                // 查询结果只需要电话号码这一列
                 new String [] { CallNote.PHONE_NUMBER },
+                // 查询条件：笔记ID等于指定值且MIME类型为电话记录类型
                 CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
+                // 查询条件参数：笔记ID和电话记录的MIME类型
                 new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
+                // 排序参数：此处不需要排序，所以为null
                 null);
 
+        // 检查查询结果是否不为空且能够移动到第一行
         if (cursor != null && cursor.moveToFirst()) {
             try {
+                // 尝试从查询结果中获取电话号码列的值
                 return cursor.getString(0);
             } catch (IndexOutOfBoundsException e) {
+                // 如果发生索引越界异常，记录错误日志
                 Log.e(TAG, "Get call number fails " + e.toString());
             } finally {
+                // 确保无论是否发生异常，都关闭游标以释放资源
                 cursor.close();
             }
         }
+        // 如果查询结果为空或无法获取电话号码，返回空字符串
         return "";
     }
 
+    // 定义一个静态方法，用于通过电话号码和通话日期获取笔记ID
     public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+        // 使用ContentResolver查询数据库，获取符合条件的Cursor对象
         Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                // 查询结果只需要CallNote.NOTE_ID这一列
                 new String [] { CallNote.NOTE_ID },
+                // 查询条件：通话日期等于callDate，MIME类型等于CallNote.CONTENT_ITEM_TYPE，
+                // 并且电话号码等于phoneNumber
                 CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
                 + CallNote.PHONE_NUMBER + ",?)",
+                // 查询条件的参数：callDate，CallNote.CONTENT_ITEM_TYPE，phoneNumber
                 new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber },
+                // 排序方式：无
                 null);
 
+        // 如果查询结果不为空
         if (cursor != null) {
+            // 如果Cursor中有数据
             if (cursor.moveToFirst()) {
                 try {
+                    // 尝试从Cursor中获取NOTE_ID列的值并返回
                     return cursor.getLong(0);
                 } catch (IndexOutOfBoundsException e) {
+                    // 如果发生索引越界异常，记录错误日志
                     Log.e(TAG, "Get call note id fails " + e.toString());
                 }
             }
+            // 关闭Cursor
             cursor.close();
         }
+        // 如果查询结果为空或者没有数据，返回0
         return 0;
     }
 
+    // 定义一个静态方法，用于根据笔记ID获取笔记摘要
     public static String getSnippetById(ContentResolver resolver, long noteId) {
         Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
                 new String [] { NoteColumns.SNIPPET },
@@ -282,14 +381,21 @@ public class DataUtils {
         throw new IllegalArgumentException("Note is not found with id: " + noteId);
     }
 
+    // 定义一个公共的静态方法，用于获取格式化后的代码片段
     public static String getFormattedSnippet(String snippet) {
+        // 检查传入的代码片段是否为null
         if (snippet != null) {
+            // 去除代码片段两端的空白字符
             snippet = snippet.trim();
+            // 查找代码片段中的第一个换行符的位置
             int index = snippet.indexOf('\n');
+            // 如果找到了换行符
             if (index != -1) {
+                // 截取从开始到第一个换行符之前的子字符串
                 snippet = snippet.substring(0, index);
             }
         }
+        // 返回格式化后的代码片段
         return snippet;
     }
 }

src/note_but_github/app/src/main/java/net/micode/notes/tool/GTaskStringUtils.java

@@ -18,96 +18,142 @@ package net.micode.notes.tool;
 
 public class GTaskStringUtils {
 
+    // 定义常量，用于表示JSON中的action_id字段
     public final static String GTASK_JSON_ACTION_ID = "action_id";
 
+    // 定义常量，用于表示JSON中的action_list字段
     public final static String GTASK_JSON_ACTION_LIST = "action_list";
 
+    // 定义常量，用于表示JSON中的action_type字段
     public final static String GTASK_JSON_ACTION_TYPE = "action_type";
 
+    // 定义常量，用于表示JSON中的action_type为create的字段
     public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
 
+    // 定义常量，用于表示JSON中的action_type为get_all的字段
     public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
 
+    // 定义常量，用于表示JSON中的action_type为move的字段
     public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
 
+    // 定义常量，用于表示JSON中的action_type为update的字段
     public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
 
+    // 定义常量，用于表示JSON中的creator_id字段
     public final static String GTASK_JSON_CREATOR_ID = "creator_id";
 
+    // 定义常量，用于表示JSON中的child_entity字段
     public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
 
+    // 定义常量，用于表示JSON中的client_version字段
     public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
 
+    // 定义常量，用于表示JSON中的completed字段
     public final static String GTASK_JSON_COMPLETED = "completed";
 
+    // 定义常量，用于表示JSON中的current_list_id字段
     public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
 
+    // 定义常量，用于表示JSON中的default_list_id字段
     public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
 
+    // 定义常量，用于表示JSON中的deleted字段
     public final static String GTASK_JSON_DELETED = "deleted";
 
+    // 定义常量，用于表示JSON中的dest_list字段
     public final static String GTASK_JSON_DEST_LIST = "dest_list";
 
+    // 定义常量，用于表示JSON中的dest_parent字段
     public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
 
+    // 定义常量，用于表示JSON中的dest_parent_type字段
     public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
 
+    // 定义常量，用于表示JSON中的entity_delta字段
     public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
 
+    // 定义常量，用于表示JSON中的entity_type字段
     public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
 
+    // 定义常量，用于表示JSON中的get_deleted字段
     public final static String GTASK_JSON_GET_DELETED = "get_deleted";
 
+    // 定义常量，用于表示JSON中的id字段
     public final static String GTASK_JSON_ID = "id";
 
+    // 定义常量，用于表示JSON中的index字段
     public final static String GTASK_JSON_INDEX = "index";
 
+    // 定义常量，用于表示JSON中的last_modified字段
     public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
 
+    // 定义常量，用于表示JSON中的latest_sync_point字段
     public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
 
+    // 定义常量，用于表示JSON中的list_id字段
     public final static String GTASK_JSON_LIST_ID = "list_id";
 
+    // 定义常量，用于表示JSON中的lists字段
     public final static String GTASK_JSON_LISTS = "lists";
 
+    // 定义常量，用于表示JSON中的name字段
     public final static String GTASK_JSON_NAME = "name";
 
+    // 定义常量，用于表示JSON中的new_id字段
     public final static String GTASK_JSON_NEW_ID = "new_id";
 
+    // 定义常量，用于表示JSON中的notes字段
     public final static String GTASK_JSON_NOTES = "notes";
 
+    // 定义常量，用于表示JSON中的parent_id字段
     public final static String GTASK_JSON_PARENT_ID = "parent_id";
 
+    // 定义常量，用于表示JSON中的prior_sibling_id字段
     public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
 
+    // 定义常量，用于表示JSON中的results字段
     public final static String GTASK_JSON_RESULTS = "results";
 
+    // 定义常量，用于表示JSON中的source_list字段
     public final static String GTASK_JSON_SOURCE_LIST = "source_list";
 
+    // 定义常量，用于表示JSON中的tasks字段
     public final static String GTASK_JSON_TASKS = "tasks";
 
+    // 定义常量，用于表示JSON中的type字段
     public final static String GTASK_JSON_TYPE = "type";
 
+    // 定义常量，用于表示JSON中的type为GROUP的字段
     public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
 
+    // 定义常量，用于表示JSON中的type为TASK的字段
     public final static String GTASK_JSON_TYPE_TASK = "TASK";
 
+    // 定义常量，用于表示JSON中的user字段
     public final static String GTASK_JSON_USER = "user";
 
+    // 定义常量，用于表示MIUI文件夹前缀
     public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
 
+    // 定义常量，用于表示默认文件夹名称
     public final static String FOLDER_DEFAULT = "Default";
 
+    // 定义常量，用于表示通话记录文件夹名称
     public final static String FOLDER_CALL_NOTE = "Call_Note";
 
+    // 定义常量，用于表示元数据文件夹名称
     public final static String FOLDER_META = "METADATA";
 
+    // 定义常量，用于表示元数据中的任务ID字段
     public final static String META_HEAD_GTASK_ID = "meta_gid";
 
+    // 定义常量，用于表示元数据中的笔记字段
     public final static String META_HEAD_NOTE = "meta_note";
 
+    // 定义常量，用于表示元数据中的数据字段
     public final static String META_HEAD_DATA = "meta_data";
 
+    // 定义常量，用于表示元数据笔记的名称
     public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
 
 }

src/note_but_github/app/src/main/java/net/micode/notes/tool/ResourceParser.java

@@ -39,21 +39,24 @@ public class ResourceParser {
 
     public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
 
+    // 定义一个名为NoteBgResources的公共静态类，用于管理音符和笔记标题的背景资源
     public static class NoteBgResources {
+        // 定义一个私有的静态整型数组，用于存储编辑背景资源的ID
         private final static int [] BG_EDIT_RESOURCES = new int [] {
-            R.drawable.edit_yellow,
-            R.drawable.edit_blue,
-            R.drawable.edit_white,
-            R.drawable.edit_green,
-            R.drawable.edit_red
+            R.drawable.edit_yellow,  // 黄色编辑背景资源ID
+            R.drawable.edit_blue,    // 蓝色编辑背景资源ID
+            R.drawable.edit_white,   // 白色编辑背景资源ID
+            R.drawable.edit_green,   // 绿色编辑背景资源ID
+            R.drawable.edit_red      // 红色编辑背景资源ID
         };
 
+        // 定义一个私有的静态整型数组，用于存储编辑标题背景资源的ID
         private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
-            R.drawable.edit_title_yellow,
-            R.drawable.edit_title_blue,
-            R.drawable.edit_title_white,
-            R.drawable.edit_title_green,
-            R.drawable.edit_title_red
+            R.drawable.edit_title_yellow,  // 黄色编辑标题背景资源ID
+            R.drawable.edit_title_blue,    // 蓝色编辑标题背景资源ID
+            R.drawable.edit_title_white,   // 白色编辑标题背景资源ID
+            R.drawable.edit_title_green,   // 绿色编辑标题背景资源ID
+            R.drawable.edit_title_red      // 红色编辑标题背景资源ID
         };
 
         // 定义一个公共的静态方法，用于获取音符背景资源的ID
@@ -128,19 +131,27 @@ public class ResourceParser {
             return BG_FIRST_RESOURCES[id];
         }
 
+        // 定义一个公共的静态方法，用于获取音符背景的最后资源ID
         public static int getNoteBgLastRes(int id) {
+            // 通过传入的id参数，从BG_LAST_RESOURCES数组中获取对应的资源ID并返回
             return BG_LAST_RESOURCES[id];
         }
 
+        // 定义一个公共的静态方法，用于获取单个音符背景资源的ID
         public static int getNoteBgSingleRes(int id) {
+            // 通过传入的id参数，从BG_SINGLE_RESOURCES数组中获取对应的资源ID并返回
             return BG_SINGLE_RESOURCES[id];
         }
 
+        // 定义一个公共的静态方法，用于获取普通背景资源的ID
         public static int getNoteBgNormalRes(int id) {
+            // 通过传入的id参数，从BG_NORMAL_RESOURCES数组中获取对应的背景资源ID
             return BG_NORMAL_RESOURCES[id];
         }
 
+        // 定义一个公共的静态方法，用于获取文件夹背景资源的ID
         public static int getFolderBgRes() {
+            // 返回R.drawable资源类中名为list_folder的资源ID
             return R.drawable.list_folder;
         }
     }