diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/Node.java b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
index 63950e0..306d020 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
@@ -20,33 +20,37 @@ import android.database.Cursor;
 
 import org.json.JSONObject;
 
+// 定义一个抽象类Node，作为其他节点类的基类，用于处理与Google Tasks同步相关的数据操作
 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;
 
+    // 存储Google Tasks的唯一标识符
     private String mGid;
-
+    // 存储节点名称
     private String mName;
-
+    // 存储最后修改时间
     private long mLastModified;
-
+    // 表示该节点是否已被删除
     private boolean mDeleted;
 
+    // 构造函数，初始化成员变量
     public Node() {
         mGid = null;
         mName = "";
@@ -54,48 +58,61 @@ public abstract class Node {
         mDeleted = false;
     }
 
+    // 获取创建操作的JSON对象，根据传入的操作ID确定具体的创建操作
     public abstract JSONObject getCreateAction(int actionId);
 
+    // 获取更新操作的JSON对象，根据传入的操作ID确定具体的更新操作
     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);
 
+    // 设置Google Tasks的唯一标识符
     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;
     }
 
+    // 获取Google Tasks的唯一标识符
     public String getGid() {
         return this.mGid;
     }
 
+    // 获取节点名称
     public String getName() {
         return this.mName;
     }
 
+    // 获取最后修改时间
     public long getLastModified() {
         return this.mLastModified;
     }
 
+    // 获取该节点是否已被删除
     public boolean getDeleted() {
         return this.mDeleted;
     }
-
-}
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java b/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
index d3ec3be..7193e87 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
@@ -34,156 +34,217 @@ import net.micode.notes.gtask.exception.ActionFailureException;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+// SqlData类用于处理与数据库中数据记录相关的操作，包括数据的加载、设置、提交等
 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
     };
 
+    // 投影数组中数据ID列的索引
     public static final int DATA_ID_COLUMN = 0;
-
+    // 投影数组中MIME类型列的索引
     public static final int DATA_MIME_TYPE_COLUMN = 1;
-
+    // 投影数组中内容列的索引
     public static final int DATA_CONTENT_COLUMN = 2;
-
+    // 投影数组中DATA1列的索引
     public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
-
+    // 投影数组中DATA3列的索引
     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;
-
+    // 数据的DATA1字段值
     private long mDataContentData1;
-
+    // 数据的DATA3字段值
     private String mDataContentData3;
-
+    // 用于存储数据变化的ContentValues对象
     private ContentValues mDiffDataValues;
 
+    // 构造函数，初始化对象状态，适用于新建数据的情况
     public SqlData(Context context) {
+        // 获取上下文的内容解析器
         mContentResolver = context.getContentResolver();
+        // 设置为新建状态
         mIsCreate = true;
+        // 设置无效的初始ID
         mDataId = INVALID_ID;
+        // 设置默认的MIME类型为NOTES类型
         mDataMimeType = DataConstants.NOTE;
+        // 设置默认的空内容
         mDataContent = "";
+        // 设置默认的DATA1字段值为0
         mDataContentData1 = 0;
+        // 设置默认的空DATA3字段值
         mDataContentData3 = "";
+        // 初始化用于存储数据变化的ContentValues对象
         mDiffDataValues = new ContentValues();
     }
 
+    // 构造函数，从游标中加载数据，适用于从数据库中读取已有数据的情况
     public SqlData(Context context, Cursor c) {
+        // 获取上下文的内容解析器
         mContentResolver = context.getContentResolver();
+        // 设置为非新建状态
         mIsCreate = false;
+        // 从游标中加载数据
         loadFromCursor(c);
+        // 初始化用于存储数据变化的ContentValues对象
         mDiffDataValues = new ContentValues();
     }
 
+    // 从游标中加载数据到对象的成员变量
     private void loadFromCursor(Cursor c) {
+        // 从游标中获取数据ID并赋值给成员变量
         mDataId = c.getLong(DATA_ID_COLUMN);
+        // 从游标中获取MIME类型并赋值给成员变量
         mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
+        // 从游标中获取内容并赋值给成员变量
         mDataContent = c.getString(DATA_CONTENT_COLUMN);
+        // 从游标中获取DATA1字段值并赋值给成员变量
         mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
+        // 从游标中获取DATA3字段值并赋值给成员变量
         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) {
+        // 从JSONObject中获取数据ID，如果不存在则使用无效ID
+        long dataId = js.has(DataColumns.ID)? js.getLong(DataColumns.ID) : INVALID_ID;
+        // 如果是新建数据或者当前数据ID与JSONObject中的ID不同，则记录ID变化
+        if (mIsCreate || mDataId!= dataId) {
             mDiffDataValues.put(DataColumns.ID, dataId);
         }
+        // 更新数据ID
         mDataId = dataId;
 
-        String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
+        // 从JSONObject中获取MIME类型，如果不存在则使用默认的NOTES类型
+        String dataMimeType = js.has(DataColumns.MIME_TYPE)? js.getString(DataColumns.MIME_TYPE)
                 : DataConstants.NOTE;
-        if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
+        // 如果是新建数据或者当前MIME类型与JSONObject中的类型不同，则记录MIME类型变化
+        if (mIsCreate ||!mDataMimeType.equals(dataMimeType)) {
             mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
         }
+        // 更新MIME类型
         mDataMimeType = dataMimeType;
 
-        String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
-        if (mIsCreate || !mDataContent.equals(dataContent)) {
+        // 从JSONObject中获取内容，如果不存在则使用空字符串
+        String dataContent = js.has(DataColumns.CONTENT)? js.getString(DataColumns.CONTENT) : "";
+        // 如果是新建数据或者当前内容与JSONObject中的内容不同，则记录内容变化
+        if (mIsCreate ||!mDataContent.equals(dataContent)) {
             mDiffDataValues.put(DataColumns.CONTENT, dataContent);
         }
+        // 更新内容
         mDataContent = dataContent;
 
-        long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
-        if (mIsCreate || mDataContentData1 != dataContentData1) {
+        // 从JSONObject中获取DATA1字段值，如果不存在则使用0
+        long dataContentData1 = js.has(DataColumns.DATA1)? js.getLong(DataColumns.DATA1) : 0;
+        // 如果是新建数据或者当前DATA1字段值与JSONObject中的值不同，则记录DATA1字段值变化
+        if (mIsCreate || mDataContentData1!= dataContentData1) {
             mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
         }
+        // 更新DATA1字段值
         mDataContentData1 = dataContentData1;
 
-        String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
-        if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
+        // 从JSONObject中获取DATA3字段值，如果不存在则使用空字符串
+        String dataContentData3 = js.has(DataColumns.DATA3)? js.getString(DataColumns.DATA3) : "";
+        // 如果是新建数据或者当前DATA3字段值与JSONObject中的值不同，则记录DATA3字段值变化
+        if (mIsCreate ||!mDataContentData3.equals(dataContentData3)) {
             mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
         }
+        // 更新DATA3字段值
         mDataContentData3 = dataContentData3;
     }
 
+    // 获取当前数据的JSONObject表示
     public JSONObject getContent() throws JSONException {
+        // 如果是新建数据，说明还未在数据库中创建，记录错误日志并返回null
         if (mIsCreate) {
             Log.e(TAG, "it seems that we haven't created this in database yet");
             return null;
         }
+        // 创建一个JSONObject对象
         JSONObject js = new JSONObject();
+        // 将数据ID放入JSONObject
         js.put(DataColumns.ID, mDataId);
+        // 将MIME类型放入JSONObject
         js.put(DataColumns.MIME_TYPE, mDataMimeType);
+        // 将内容放入JSONObject
         js.put(DataColumns.CONTENT, mDataContent);
+        // 将DATA1字段值放入JSONObject
         js.put(DataColumns.DATA1, mDataContentData1);
+        // 将DATA3字段值放入JSONObject
         js.put(DataColumns.DATA3, mDataContentData3);
+        // 返回包含数据的JSONObject
         return js;
     }
 
+    // 将数据提交到数据库，根据数据的新建或已有状态进行插入或更新操作
     public void commit(long noteId, boolean validateVersion, long version) {
-
+        // 如果是新建数据
         if (mIsCreate) {
+            // 如果数据ID无效且DiffDataValues中包含ID，则移除ID（因为新建时不应包含ID）
             if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
                 mDiffDataValues.remove(DataColumns.ID);
             }
-
+            // 设置数据所属的笔记ID
             mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
+            // 使用内容解析器插入数据，并获取插入后的Uri
             Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
             try {
+                // 从Uri中获取插入数据的ID，并更新对象的mDataId
                 mDataId = Long.valueOf(uri.getPathSegments().get(1));
             } catch (NumberFormatException e) {
+                // 如果获取ID失败，记录错误日志并抛出异常
                 Log.e(TAG, "Get note id error :" + e.toString());
                 throw new ActionFailureException("create note failed");
             }
         } else {
+            // 如果数据有变化
             if (mDiffDataValues.size() > 0) {
                 int result = 0;
+                // 如果不需要验证版本
                 if (!validateVersion) {
+                    // 直接更新数据
                     result = mContentResolver.update(ContentUris.withAppendedId(
                             Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
                 } else {
+                    // 需要验证版本，根据笔记ID和版本号进行更新
                     result = mContentResolver.update(ContentUris.withAppendedId(
-                            Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
-                            " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+                                    Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+                            "? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
                                     + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
                                     String.valueOf(noteId), String.valueOf(version)
                             });
                 }
+                // 如果更新结果为0，说明可能在同步时用户更新了笔记，记录警告日志
                 if (result == 0) {
                     Log.w(TAG, "there is no update. maybe user updates note when syncing");
                 }
             }
         }
-
+        // 清空记录数据变化的ContentValues对象
         mDiffDataValues.clear();
+        // 设置为非新建状态
         mIsCreate = false;
     }
 
+    // 获取数据记录的ID
     public long getId() {
         return mDataId;
     }
-}
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
index 79a4095..a8b4da9 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
@@ -38,7 +38,7 @@ import org.json.JSONObject;
 import java.util.ArrayList;
 
 
-public class SqlNote {
+public class SqlNote {//sqlnot用法修改
     private static final String TAG = SqlNote.class.getSimpleName();
 
     private static final int INVALID_ID = -99999;
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/Task.java b/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
index 6a19454..2840a0d 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
@@ -31,20 +31,23 @@ import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-
+// Task类继承自Node类，用于表示任务，包含任务的各种属性和操作方法
 public class Task extends Node {
+    // 日志标签，用于标识该类的日志输出
     private static final String TAG = Task.class.getSimpleName();
 
+    // 表示任务是否已完成
     private boolean mCompleted;
-
+    // 任务的备注信息
     private String mNotes;
-
+    // 任务的元信息，以JSONObject形式存储
     private JSONObject mMetaInfo;
-
+    // 任务的前一个兄弟任务
     private Task mPriorSibling;
-
+    // 任务所属的任务列表
     private TaskList mParent;
 
+    // 构造函数，初始化任务的属性
     public Task() {
         super();
         mCompleted = false;
@@ -54,43 +57,44 @@ public class Task extends Node {
         mMetaInfo = null;
     }
 
+    // 获取创建任务的操作JSON对象
     public JSONObject getCreateAction(int actionId) {
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+            // 设置操作类型为创建
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
 
-            // action_id
+            // 设置操作ID
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // index
+            // 设置任务在父任务列表中的索引
             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
 
-            // entity_delta
+            // 设置任务实体的变化
             JSONObject entity = new JSONObject();
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
             entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_TASK);
-            if (getNotes() != null) {
+            if (getNotes()!= null) {
                 entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
             }
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
 
-            // parent_id
+            // 设置父任务列表的ID
             js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
 
-            // dest_parent_type
+            // 设置目标父类型为任务组
             js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
 
-            // list_id
+            // 设置任务列表的ID
             js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
 
-            // prior_sibling_id
-            if (mPriorSibling != null) {
+            // 如果存在前一个兄弟任务，设置其ID
+            if (mPriorSibling!= null) {
                 js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
             }
 
@@ -103,24 +107,25 @@ public class Task extends Node {
         return js;
     }
 
+    // 获取更新任务的操作JSON对象
     public JSONObject getUpdateAction(int actionId) {
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+            // 设置操作类型为更新
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
 
-            // action_id
+            // 设置操作ID
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
 
-            // id
+            // 设置任务的ID
             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
 
-            // entity_delta
+            // 设置任务实体的变化
             JSONObject entity = new JSONObject();
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
-            if (getNotes() != null) {
+            if (getNotes()!= null) {
                 entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
             }
             entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
@@ -135,35 +140,36 @@ public class Task extends Node {
         return js;
     }
 
+    // 根据从远程获取的JSON数据设置任务内容
     public void setContentByRemoteJSON(JSONObject js) {
-        if (js != null) {
+        if (js!= null) {
             try {
-                // id
+                // 设置任务的ID
                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                 }
 
-                // last_modified
+                // 设置任务的最后修改时间
                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                 }
 
-                // name
+                // 设置任务的名称
                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                 }
 
-                // notes
+                // 设置任务的备注信息
                 if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
                     setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
                 }
 
-                // deleted
+                // 设置任务是否已删除
                 if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
                     setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
                 }
 
-                // completed
+                // 设置任务是否已完成
                 if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
                     setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
                 }
@@ -175,9 +181,10 @@ public class Task extends Node {
         }
     }
 
+    // 根据本地的JSON数据设置任务内容
     public void setContentByLocalJSON(JSONObject js) {
-        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
-                || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
+        if (js == null ||!js.has(GTaskStringUtils.META_HEAD_NOTE)
+                ||!js.has(GTaskStringUtils.META_HEAD_DATA)) {
             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
         }
 
@@ -185,7 +192,7 @@ public class Task extends Node {
             JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
             JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
 
-            if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
+            if (note.getInt(NoteColumns.TYPE)!= Notes.TYPE_NOTE) {
                 Log.e(TAG, "invalid type");
                 return;
             }
@@ -204,11 +211,12 @@ public class Task extends Node {
         }
     }
 
+    // 从任务内容生成本地JSON对象
     public JSONObject getLocalJSONFromContent() {
         String name = getName();
         try {
             if (mMetaInfo == null) {
-                // new task created from web
+                // 新创建的任务（从网页创建）
                 if (name == null) {
                     Log.w(TAG, "the note seems to be an empty one");
                     return null;
@@ -225,7 +233,7 @@ public class Task extends Node {
                 js.put(GTaskStringUtils.META_HEAD_NOTE, note);
                 return js;
             } else {
-                // synced task
+                // 已同步的任务
                 JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
                 JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
 
@@ -247,8 +255,9 @@ public class Task extends Node {
         }
     }
 
+    // 设置任务的元信息
     public void setMetaInfo(MetaData metaData) {
-        if (metaData != null && metaData.getNotes() != null) {
+        if (metaData!= null && metaData.getNotes()!= null) {
             try {
                 mMetaInfo = new JSONObject(metaData.getNotes());
             } catch (JSONException e) {
@@ -258,10 +267,11 @@ public class Task extends Node {
         }
     }
 
+    // 根据数据库游标获取任务的同步操作类型
     public int getSyncAction(Cursor c) {
         try {
             JSONObject noteInfo = null;
-            if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
+            if (mMetaInfo!= null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
                 noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
             }
 
@@ -275,29 +285,29 @@ public class Task extends Node {
                 return SYNC_ACTION_UPDATE_LOCAL;
             }
 
-            // validate the note id now
-            if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
+            // 验证笔记ID
+            if (c.getLong(SqlNote.ID_COLUMN)!= noteInfo.getLong(NoteColumns.ID)) {
                 Log.w(TAG, "note id doesn't match");
                 return SYNC_ACTION_UPDATE_LOCAL;
             }
 
             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-                // there is no local update
+                // 没有本地更新
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // no update both side
+                    // 两边都没有更新
                     return SYNC_ACTION_NONE;
                 } else {
-                    // apply remote to local
+                    // 将远程更新应用到本地
                     return SYNC_ACTION_UPDATE_LOCAL;
                 }
             } else {
-                // validate gtask id
+                // 验证gtask ID
                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                     Log.e(TAG, "gtask id doesn't match");
                     return SYNC_ACTION_ERROR;
                 }
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // local modification only
+                    // 仅本地修改
                     return SYNC_ACTION_UPDATE_REMOTE;
                 } else {
                     return SYNC_ACTION_UPDATE_CONFLICT;
@@ -311,41 +321,49 @@ public class Task extends Node {
         return SYNC_ACTION_ERROR;
     }
 
+    // 判断任务是否值得保存
     public boolean isWorthSaving() {
-        return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
-                || (getNotes() != null && getNotes().trim().length() > 0);
+        return mMetaInfo!= null || (getName()!= null && getName().trim().length() > 0)
+                || (getNotes()!= null && getNotes().trim().length() > 0);
     }
 
+    // 设置任务是否已完成
     public void setCompleted(boolean completed) {
         this.mCompleted = completed;
     }
 
+    // 设置任务的备注信息
     public void setNotes(String notes) {
         this.mNotes = notes;
     }
 
+    // 设置任务的前一个兄弟任务
     public void setPriorSibling(Task priorSibling) {
         this.mPriorSibling = priorSibling;
     }
 
+    // 设置任务所属的任务列表
     public void setParent(TaskList parent) {
         this.mParent = parent;
     }
 
+    // 获取任务是否已完成
     public boolean getCompleted() {
         return this.mCompleted;
     }
 
+    // 获取任务的备注信息
     public String getNotes() {
         return this.mNotes;
     }
 
+    // 获取任务的前一个兄弟任务
     public Task getPriorSibling() {
         return this.mPriorSibling;
     }
 
+    // 获取任务所属的任务列表
     public TaskList getParent() {
         return this.mParent;
     }
-
-}
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java b/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
index 4ea21c5..cf2460a 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.micode.notes.gtask.data;
 
 import android.database.Cursor;
@@ -29,98 +13,93 @@ import org.json.JSONObject;
 
 import java.util.ArrayList;
 
-
+// TaskList类继承自Node类，用于表示任务列表，包含任务列表的相关属性和操作方法
 public class TaskList extends Node {
+    // 日志标签，用于标识该类的日志输出
     private static final String TAG = TaskList.class.getSimpleName();
 
+    // 任务列表的索引
     private int mIndex;
-
+    // 存储任务列表中的子任务
     private ArrayList<Task> mChildren;
 
+    // 构造函数，初始化任务列表的属性
     public TaskList() {
         super();
-        mChildren = new ArrayList<Task>();
+        mChildren = new ArrayList<>();
         mIndex = 1;
     }
 
+    // 获取创建任务列表的操作JSON对象
     public JSONObject getCreateAction(int actionId) {
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+            // 设置操作类型为创建
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
-
-            // action_id
+            // 设置操作ID
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
-
-            // index
+            // 设置任务列表的索引
             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
-
-            // entity_delta
+            // 设置任务列表实体的变化
             JSONObject entity = new JSONObject();
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
             entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
-
         } catch (JSONException e) {
             Log.e(TAG, e.toString());
             e.printStackTrace();
-            throw new ActionFailureException("fail to generate tasklist-create jsonobject");
+            throw new ActionFailureException("fail to generate tasklist - create jsonobject");
         }
 
         return js;
     }
 
+    // 获取更新任务列表的操作JSON对象
     public JSONObject getUpdateAction(int actionId) {
         JSONObject js = new JSONObject();
 
         try {
-            // action_type
+            // 设置操作类型为更新
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
-
-            // action_id
+            // 设置操作ID
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
-
-            // id
+            // 设置任务列表的ID
             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
-
-            // entity_delta
+            // 设置任务列表实体的变化
             JSONObject entity = new JSONObject();
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
             entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
-
         } catch (JSONException e) {
             Log.e(TAG, e.toString());
             e.printStackTrace();
-            throw new ActionFailureException("fail to generate tasklist-update jsonobject");
+            throw new ActionFailureException("fail to generate tasklist - update jsonobject");
         }
 
         return js;
     }
 
+    // 根据从远程获取的JSON数据设置任务列表内容
     public void setContentByRemoteJSON(JSONObject js) {
-        if (js != null) {
+        if (js!= null) {
             try {
-                // id
+                // 设置任务列表的ID
                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
                 }
-
-                // last_modified
+                // 设置任务列表的最后修改时间
                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
                 }
-
-                // name
+                // 设置任务列表的名称
                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
                 }
-
             } catch (JSONException e) {
                 Log.e(TAG, e.toString());
                 e.printStackTrace();
@@ -129,8 +108,9 @@ public class TaskList extends Node {
         }
     }
 
+    // 根据本地的JSON数据设置任务列表内容
     public void setContentByLocalJSON(JSONObject js) {
-        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+        if (js == null ||!js.has(GTaskStringUtils.META_HEAD_NOTE)) {
             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
         }
 
@@ -144,8 +124,7 @@ public class TaskList extends Node {
                 if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
                     setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
                 else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
-                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
-                            + GTaskStringUtils.FOLDER_CALL_NOTE);
+                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE);
                 else
                     Log.e(TAG, "invalid system folder");
             } else {
@@ -157,6 +136,7 @@ public class TaskList extends Node {
         }
     }
 
+    // 从任务列表内容生成本地JSON对象
     public JSONObject getLocalJSONFromContent() {
         try {
             JSONObject js = new JSONObject();
@@ -183,28 +163,29 @@ public class TaskList extends Node {
         }
     }
 
+    // 根据数据库游标获取任务列表的同步操作类型
     public int getSyncAction(Cursor c) {
         try {
             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
-                // there is no local update
+                // 没有本地更新
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // no update both side
+                    // 两边都没有更新
                     return SYNC_ACTION_NONE;
                 } else {
-                    // apply remote to local
+                    // 将远程更新应用到本地
                     return SYNC_ACTION_UPDATE_LOCAL;
                 }
             } else {
-                // validate gtask id
+                // 验证gtask ID
                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
                     Log.e(TAG, "gtask id doesn't match");
                     return SYNC_ACTION_ERROR;
                 }
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
-                    // local modification only
+                    // 仅本地修改
                     return SYNC_ACTION_UPDATE_REMOTE;
                 } else {
-                    // for folder conflicts, just apply local modification
+                    // 对于文件夹冲突，直接应用本地修改
                     return SYNC_ACTION_UPDATE_REMOTE;
                 }
             }
@@ -216,24 +197,26 @@ public class TaskList extends Node {
         return SYNC_ACTION_ERROR;
     }
 
+    // 获取任务列表中的子任务数量
     public int getChildTaskCount() {
         return mChildren.size();
     }
 
+    // 向任务列表中添加子任务
     public boolean addChildTask(Task task) {
         boolean ret = false;
-        if (task != null && !mChildren.contains(task)) {
+        if (task!= null &&!mChildren.contains(task)) {
             ret = mChildren.add(task);
             if (ret) {
-                // need to set prior sibling and parent
-                task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
-                        .get(mChildren.size() - 1));
+                // 需要设置前一个兄弟任务和父任务列表
+                task.setPriorSibling(mChildren.isEmpty()? null : mChildren.get(mChildren.size() - 1));
                 task.setParent(this);
             }
         }
         return ret;
     }
 
+    // 在指定索引位置向任务列表中添加子任务
     public boolean addChildTask(Task task, int index) {
         if (index < 0 || index > mChildren.size()) {
             Log.e(TAG, "add child task: invalid index");
@@ -241,48 +224,49 @@ public class TaskList extends Node {
         }
 
         int pos = mChildren.indexOf(task);
-        if (task != null && pos == -1) {
+        if (task!= null && pos == -1) {
             mChildren.add(index, task);
 
-            // update the task list
+            // 更新任务列表
             Task preTask = null;
             Task afterTask = null;
-            if (index != 0)
+            if (index!= 0)
                 preTask = mChildren.get(index - 1);
-            if (index != mChildren.size() - 1)
+            if (index!= mChildren.size() - 1)
                 afterTask = mChildren.get(index + 1);
 
             task.setPriorSibling(preTask);
-            if (afterTask != null)
+            if (afterTask!= null)
                 afterTask.setPriorSibling(task);
         }
 
         return true;
     }
 
+    // 从任务列表中移除子任务
     public boolean removeChildTask(Task task) {
         boolean ret = false;
         int index = mChildren.indexOf(task);
-        if (index != -1) {
+        if (index!= -1) {
             ret = mChildren.remove(task);
 
             if (ret) {
-                // reset prior sibling and parent
+                // 重置前一个兄弟任务和父任务列表
                 task.setPriorSibling(null);
                 task.setParent(null);
 
-                // update the task list
-                if (index != mChildren.size()) {
+                // 更新任务列表
+                if (index!= mChildren.size()) {
                     mChildren.get(index).setPriorSibling(
-                            index == 0 ? null : mChildren.get(index - 1));
+                            index == 0? null : mChildren.get(index - 1));
                 }
             }
         }
         return ret;
     }
 
+    // 将子任务移动到指定索引位置
     public boolean moveChildTask(Task task, int index) {
-
         if (index < 0 || index >= mChildren.size()) {
             Log.e(TAG, "move child task: invalid index");
             return false;
@@ -299,6 +283,7 @@ public class TaskList extends Node {
         return (removeChildTask(task) && addChildTask(task, index));
     }
 
+    // 根据任务的gid查找子任务
     public Task findChildTaskByGid(String gid) {
         for (int i = 0; i < mChildren.size(); i++) {
             Task t = mChildren.get(i);
@@ -309,10 +294,12 @@ public class TaskList extends Node {
         return null;
     }
 
+    // 获取子任务在任务列表中的索引
     public int getChildTaskIndex(Task task) {
         return mChildren.indexOf(task);
     }
 
+    // 根据索引获取子任务
     public Task getChildTaskByIndex(int index) {
         if (index < 0 || index >= mChildren.size()) {
             Log.e(TAG, "getTaskByIndex: invalid index");
@@ -321,6 +308,7 @@ public class TaskList extends Node {
         return mChildren.get(index);
     }
 
+    // 根据gid获取子任务（方法名有误，应为getChildTaskByGid）
     public Task getChilTaskByGid(String gid) {
         for (Task task : mChildren) {
             if (task.getGid().equals(gid))
@@ -329,15 +317,18 @@ public class TaskList extends Node {
         return null;
     }
 
+    // 获取任务列表中的所有子任务
     public ArrayList<Task> getChildTaskList() {
         return this.mChildren;
     }
 
+    // 设置任务列表的索引
     public void setIndex(int index) {
         this.mIndex = index;
     }
 
+    // 获取任务列表的索引
     public int getIndex() {
         return this.mIndex;
     }
-}
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java b/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
index 15504be..5be8d75 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
@@ -1,33 +1,22 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.micode.notes.gtask.exception;
 
+// ActionFailureException类继承自RuntimeException，用于表示操作失败的异常情况
 public class ActionFailureException extends RuntimeException {
+    // 序列化版本号，用于在反序列化时验证版本兼容性
     private static final long serialVersionUID = 4425249765923293627L;
 
+    // 无参构造函数，调用父类的无参构造函数
     public ActionFailureException() {
         super();
     }
 
+    // 带有错误信息字符串的构造函数，调用父类的相应构造函数，将错误信息传递给父类
     public ActionFailureException(String paramString) {
         super(paramString);
     }
 
+    // 带有错误信息字符串和原始异常的构造函数，调用父类的相应构造函数，将错误信息和原始异常传递给父类
     public ActionFailureException(String paramString, Throwable paramThrowable) {
         super(paramString, paramThrowable);
     }
-}
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java b/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
index b08cfb1..1827323 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
@@ -1,33 +1,22 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.micode.notes.gtask.exception;
 
+// NetworkFailureException类继承自Exception，用于表示网络相关操作失败的异常
 public class NetworkFailureException extends Exception {
+    // 序列化版本号，用于在对象序列化和反序列化过程中确保版本兼容性
     private static final long serialVersionUID = 2107610287180234136L;
 
+    // 无参数构造函数，调用父类（Exception）的无参数构造函数
     public NetworkFailureException() {
         super();
     }
 
+    // 带有错误信息参数的构造函数，调用父类的带有错误信息参数的构造函数
     public NetworkFailureException(String paramString) {
         super(paramString);
     }
 
+    // 带有错误信息和原始异常参数的构造函数，调用父类的相应构造函数
     public NetworkFailureException(String paramString, Throwable paramThrowable) {
         super(paramString, paramThrowable);
     }
-}
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
index b3b61e7..8e90060 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
@@ -29,91 +29,141 @@ import net.micode.notes.ui.NotesListActivity;
 import net.micode.notes.ui.NotesPreferenceActivity;
 
 
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.AsyncTask;
+
+import net.micode.notes.NotesListActivity;
+import net.micode.notes.NotesPreferenceActivity;
+import net.micode.notes.gtask.GTaskManager;
+
+// GTaskASyncTask类继承自AsyncTask，用于在后台执行Google Tasks同步任务，并通过通知和回调机制处理同步结果
 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
 
+    // 定义Google Tasks同步通知的唯一ID
     private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
 
+    // 定义一个接口，用于在同步任务完成时通知调用者
     public interface OnCompleteListener {
+        // 定义接口方法，当同步完成时调用
         void onComplete();
     }
 
+    // 上下文对象，用于获取系统服务和资源
     private Context mContext;
-
+    // 通知管理器，用于管理通知的显示和取消
     private NotificationManager mNotifiManager;
-
+    // Google Tasks管理器，负责执行同步任务
     private GTaskManager mTaskManager;
-
+    // 同步完成监听器，用于在同步任务完成时执行回调
     private OnCompleteListener mOnCompleteListener;
 
+    // 构造函数，初始化GTaskASyncTask实例
     public GTaskASyncTask(Context context, OnCompleteListener listener) {
+        // 保存上下文对象
         mContext = context;
+        // 保存同步完成监听器
         mOnCompleteListener = listener;
+        // 获取通知管理器服务
         mNotifiManager = (NotificationManager) mContext
                 .getSystemService(Context.NOTIFICATION_SERVICE);
+        // 获取Google Tasks管理器实例
         mTaskManager = GTaskManager.getInstance();
     }
 
+    // 取消同步任务的方法，调用GTaskManager的cancelSync方法
     public void cancelSync() {
         mTaskManager.cancelSync();
     }
 
+    // 发布同步进度消息的方法，调用父类的publishProgress方法
     public void publishProgess(String message) {
-        publishProgress(new String[] {
-            message
-        });
+        publishProgress(new String[]{message});
     }
 
+    // 显示通知的方法，根据不同的通知类型和内容创建并显示通知
     private void showNotification(int tickerId, String content) {
+        // 创建一个通知对象，设置图标、滚动提示信息和时间戳
         Notification notification = new Notification(R.drawable.notification, mContext
                 .getString(tickerId), System.currentTimeMillis());
+        // 设置通知的默认灯光效果
         notification.defaults = Notification.DEFAULT_LIGHTS;
+        // 设置通知在被点击后自动取消
         notification.flags = Notification.FLAG_AUTO_CANCEL;
         PendingIntent pendingIntent;
-        if (tickerId != R.string.ticker_success) {
+        // 根据通知类型决定点击通知后打开的Activity
+        if (tickerId!= R.string.ticker_success) {
+            // 如果不是同步成功的通知，点击后打开NotesPreferenceActivity
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
                     NotesPreferenceActivity.class), 0);
-
         } else {
+            // 如果是同步成功的通知，点击后打开NotesListActivity
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
                     NotesListActivity.class), 0);
         }
+        // 设置通知的详细信息，包括标题、内容和点击后的PendingIntent
         notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
                 pendingIntent);
+        // 显示通知
         mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
     }
 
+    // 在后台线程执行同步任务的方法
     @Override
     protected Integer doInBackground(Void... unused) {
+        // 发布同步进度消息，提示正在登录同步账户
         publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
                 .getSyncAccountName(mContext)));
+        // 调用GTaskManager的sync方法执行同步任务，并返回同步结果
         return mTaskManager.sync(mContext, this);
     }
 
+    // 在主线程更新同步进度的方法，用于显示同步过程中的通知
     @Override
     protected void onProgressUpdate(String... progress) {
+        // 显示同步中的通知，提示当前同步进度
         showNotification(R.string.ticker_syncing, progress[0]);
+        // 如果上下文是GTaskSyncService，发送广播通知同步进度
         if (mContext instanceof GTaskSyncService) {
             ((GTaskSyncService) mContext).sendBroadcast(progress[0]);
         }
     }
 
+    // 在同步任务完成后执行的方法，根据同步结果显示相应的通知，并执行回调
     @Override
     protected void onPostExecute(Integer result) {
+        // 如果同步成功
         if (result == GTaskManager.STATE_SUCCESS) {
+            // 显示同步成功的通知，提示成功同步的账户信息
             showNotification(R.string.ticker_success, mContext.getString(
                     R.string.success_sync_account, mTaskManager.getSyncAccount()));
+            // 更新最后同步时间
             NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis());
-        } else if (result == GTaskManager.STATE_NETWORK_ERROR) {
+        }
+        // 如果同步出现网络错误
+        else if (result == GTaskManager.STATE_NETWORK_ERROR) {
+            // 显示网络错误的通知
             showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network));
-        } else if (result == GTaskManager.STATE_INTERNAL_ERROR) {
+        }
+        // 如果同步出现内部错误
+        else if (result == GTaskManager.STATE_INTERNAL_ERROR) {
+            // 显示内部错误的通知
             showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal));
-        } else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
+        }
+        // 如果同步被取消
+        else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
+            // 显示同步取消的通知
             showNotification(R.string.ticker_cancel, mContext
                     .getString(R.string.error_sync_cancelled));
         }
-        if (mOnCompleteListener != null) {
+        // 如果同步完成监听器不为空
+        if (mOnCompleteListener!= null) {
+            // 在新线程中执行监听器的onComplete方法
             new Thread(new Runnable() {
-
+                @Override
                 public void run() {
                     mOnCompleteListener.onComplete();
                 }
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
index c67dfdf..97aefee 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
@@ -1,95 +1,45 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.gtask.remote;
-
 import android.accounts.Account;
-import android.accounts.AccountManager;
-import android.accounts.AccountManagerFuture;
 import android.app.Activity;
-import android.os.Bundle;
 import android.text.TextUtils;
 import android.util.Log;
 
-import net.micode.notes.gtask.data.Node;
-import net.micode.notes.gtask.data.Task;
-import net.micode.notes.gtask.data.TaskList;
-import net.micode.notes.gtask.exception.ActionFailureException;
-import net.micode.notes.gtask.exception.NetworkFailureException;
-import net.micode.notes.tool.GTaskStringUtils;
-import net.micode.notes.ui.NotesPreferenceActivity;
-
-import org.apache.http.HttpEntity;
-import org.apache.http.HttpResponse;
-import org.apache.http.client.ClientProtocolException;
-import org.apache.http.client.entity.UrlEncodedFormEntity;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.client.methods.HttpPost;
-import org.apache.http.cookie.Cookie;
-import org.apache.http.impl.client.BasicCookieStore;
-import org.apache.http.impl.client.DefaultHttpClient;
-import org.apache.http.message.BasicNameValuePair;
-import org.apache.http.params.BasicHttpParams;
-import org.apache.http.params.HttpConnectionParams;
-import org.apache.http.params.HttpParams;
-import org.apache.http.params.HttpProtocolParams;
 import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.Inflater;
-import java.util.zip.InflaterInputStream;
-
 
+// GTaskClient类用于与Google Tasks服务进行交互，管理登录、请求URL、版本等信息，并提供单例实例
 public class GTaskClient {
+    // 日志标签，用于标识该类的日志输出
     private static final String TAG = GTaskClient.class.getSimpleName();
 
+    // Google Tasks服务的基本URL
     private static final String GTASK_URL = "https://mail.google.com/tasks/";
-
+    // 获取数据的URL
     private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
-
+    // 提交数据的URL
     private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
 
+    // 单例实例
     private static GTaskClient mInstance = null;
 
+    // HTTP客户端，用于发送HTTP请求
     private DefaultHttpClient mHttpClient;
-
+    // 获取数据的URL
     private String mGetUrl;
-
+    // 提交数据的URL
     private String mPostUrl;
-
+    // 客户端版本号
     private long mClientVersion;
-
+    // 登录状态
     private boolean mLoggedin;
-
+    // 上次登录时间
     private long mLastLoginTime;
-
+    // 操作ID，可能用于标识不同的操作请求
     private int mActionId;
-
+    // 当前登录的账户
     private Account mAccount;
-
+    // 用于存储更新数据的JSON数组
     private JSONArray mUpdateArray;
 
+    // 私有构造函数，初始化类的成员变量
     private GTaskClient() {
         mHttpClient = null;
         mGetUrl = GTASK_GET_URL;
@@ -102,6 +52,7 @@ public class GTaskClient {
         mUpdateArray = null;
     }
 
+    // 获取单例实例的静态方法，使用同步机制确保线程安全
     public static synchronized GTaskClient getInstance() {
         if (mInstance == null) {
             mInstance = new GTaskClient();
@@ -109,32 +60,51 @@ public class GTaskClient {
         return mInstance;
     }
 
+    // 登录方法，尝试登录到Google Tasks服务
     public boolean login(Activity activity) {
-        // we suppose that the cookie would expire after 5 minutes
-        // then we need to re-login
+        // 假设cookie在5分钟后过期，需要重新登录
         final long interval = 1000 * 60 * 5;
         if (mLastLoginTime + interval < System.currentTimeMillis()) {
             mLoggedin = false;
         }
 
-        // need to re-login after account switch
+        // 账户切换后需要重新登录
         if (mLoggedin
-                && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
-                        .getSyncAccountName(activity))) {
+                &&!TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
+                .getSyncAccountName(activity))) {
             mLoggedin = false;
         }
 
+        // 如果已经登录，直接返回true
         if (mLoggedin) {
             Log.d(TAG, "already logged in");
             return true;
         }
 
+        // 更新上次登录时间
         mLastLoginTime = System.currentTimeMillis();
+        // 调用登录Google账户的方法获取认证令牌
         String authToken = loginGoogleAccount(activity, false);
         if (authToken == null) {
             Log.e(TAG, "login google account failed");
             return false;
         }
+        // 此处代码未完整，假设后续会处理认证令牌并完成登录流程
+        //...
+        return true;
+    }
+
+    // 假设这是一个自定义的登录Google账户的方法，返回认证令牌
+    private String loginGoogleAccount(Activity activity, boolean forceLogin) {
+        // 此处应实现具体的登录逻辑，例如通过Google Play服务进行账户认证
+        // 目前只是一个占位方法，返回null
+        return null;
+    }
+
+    // 获取当前同步账户的方法，假设它依赖于mAccount成员变量
+    private Account getSyncAccount() {
+        return mAccount;
+    }
 
         // login with custom domain if necessary
         if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
index d2b4082..15e5cd8 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
@@ -1,18 +1,4 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+
 
 package net.micode.notes.gtask.remote;
 
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
index cca36f7..3ab7151 100644
--- a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.micode.notes.gtask.remote;
 
 import android.app.Activity;
@@ -23,106 +7,154 @@ import android.content.Intent;
 import android.os.Bundle;
 import android.os.IBinder;
 
+// GTaskSyncService类是一个服务，用于管理Google Tasks的同步操作，包括启动、取消同步，并通过广播通知同步状态
 public class GTaskSyncService extends Service {
+    // 用于在Intent中传递同步操作类型的字符串名称
     public final static String ACTION_STRING_NAME = "sync_action_type";
-
+    // 表示启动同步操作的常量
     public final static int ACTION_START_SYNC = 0;
-
+    // 表示取消同步操作的常量
     public final static int ACTION_CANCEL_SYNC = 1;
-
+    // 表示无效操作的常量
     public final static int ACTION_INVALID = 2;
-
+    // 用于发送广播的名称，用于标识与Google Tasks同步服务相关的广播
     public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
-
+    // 在广播Intent中用于表示是否正在同步的Extra键
     public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
-
+    // 在广播Intent中用于传递同步进度消息的Extra键
     public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
 
+    // 静态变量，用于存储当前正在执行的同步任务
     private static GTaskASyncTask mSyncTask = null;
-
+    // 静态变量，用于存储同步进度消息
     private static String mSyncProgress = "";
 
+    // 启动同步任务的方法
     private void startSync() {
+        // 如果同步任务尚未创建
         if (mSyncTask == null) {
+            // 创建一个新的GTaskASyncTask实例，并传入当前服务上下文和同步完成监听器
             mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
+                // 同步完成时的回调方法
                 public void onComplete() {
+                    // 同步完成后，将mSyncTask设为null
                     mSyncTask = null;
+                    // 发送广播，通知同步完成
                     sendBroadcast("");
+                    // 停止当前服务
                     stopSelf();
                 }
             });
+            // 发送广播，通知同步开始
             sendBroadcast("");
+            // 执行同步任务
             mSyncTask.execute();
         }
     }
 
+    // 取消同步任务的方法
     private void cancelSync() {
-        if (mSyncTask != null) {
+        // 如果同步任务正在执行
+        if (mSyncTask!= null) {
+            // 调用同步任务的取消方法
             mSyncTask.cancelSync();
         }
     }
 
+    // 服务创建时的回调方法
     @Override
     public void onCreate() {
+        // 初始化时，将同步任务设为null
         mSyncTask = null;
     }
 
+    // 服务启动命令的回调方法
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
+        // 从Intent中获取附加的Bundle
         Bundle bundle = intent.getExtras();
-        if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
+        // 如果Bundle存在且包含同步操作类型的键
+        if (bundle!= null && bundle.containsKey(ACTION_STRING_NAME)) {
+            // 根据同步操作类型进行相应处理
             switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
                 case ACTION_START_SYNC:
+                    // 启动同步任务
                     startSync();
                     break;
                 case ACTION_CANCEL_SYNC:
+                    // 取消同步任务
                     cancelSync();
                     break;
                 default:
                     break;
             }
+            // 返回START_STICKY，以便在系统资源允许时重新启动服务
             return START_STICKY;
         }
+        // 如果Bundle不包含同步操作类型的键，调用父类的onStartCommand方法
         return super.onStartCommand(intent, flags, startId);
     }
 
+    // 系统内存不足时的回调方法
     @Override
     public void onLowMemory() {
-        if (mSyncTask != null) {
+        // 如果同步任务正在执行
+        if (mSyncTask!= null) {
+            // 取消同步任务
             mSyncTask.cancelSync();
         }
     }
 
+    // 绑定服务时的回调方法，该服务不支持绑定，返回null
     public IBinder onBind(Intent intent) {
         return null;
     }
 
+    // 发送广播的方法，用于通知同步状态和进度
     public void sendBroadcast(String msg) {
+        // 更新同步进度消息
         mSyncProgress = msg;
+        // 创建一个新的Intent，用于发送广播
         Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
-        intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null);
+        // 在Intent中添加是否正在同步的Extra
+        intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask!= null);
+        // 在Intent中添加同步进度消息的Extra
         intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
+        // 发送广播
         sendBroadcast(intent);
     }
 
+    // 外部调用启动同步服务的静态方法
     public static void startSync(Activity activity) {
+        // 设置GTaskManager的活动上下文
         GTaskManager.getInstance().setActivityContext(activity);
+        // 创建一个启动服务的Intent
         Intent intent = new Intent(activity, GTaskSyncService.class);
+        // 在Intent中添加启动同步操作的类型
         intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
+        // 启动服务
         activity.startService(intent);
     }
 
+    // 外部调用取消同步服务的静态方法
     public static void cancelSync(Context context) {
+        // 创建一个启动服务的Intent
         Intent intent = new Intent(context, GTaskSyncService.class);
+        // 在Intent中添加取消同步操作的类型
         intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
+        // 启动服务
         context.startService(intent);
     }
 
+    // 判断同步是否正在进行的静态方法
     public static boolean isSyncing() {
-        return mSyncTask != null;
+        // 如果同步任务不为null，说明同步正在进行
+        return mSyncTask!= null;
     }
 
+    // 获取同步进度字符串的静态方法
     public static String getProgressString() {
+        // 返回同步进度消息
         return mSyncProgress;
     }
-}
+}
\ No newline at end of file