Merge pull request '何俊杰请求合并' (#8) from hjj_branch into master

src/net/micode/notes/gtask/data/MetaData.java

@@ -16,12 +16,17 @@
 
 package net.micode.notes.gtask.data;
 
+//cursor类用于在Android中进行数据库查询操作的游标类
 import android.database.Cursor;
+//log类用于在Android应用程序中输出日志的类
 import android.util.Log;
 
+//GTaskStringUtils用于处理相关的字符串操作
 import net.micode.notes.tool.GTaskStringUtils;
 
+//JSONException类用于JSON解析过程中可能出现的异常类
 import org.json.JSONException;
+//JSONObject类用于在Java中创建和操作JSON对象的类
 import org.json.JSONObject;
 
 
@@ -29,30 +34,38 @@ public class MetaData extends Task {
     private final static String TAG = MetaData.class.getSimpleName();
 
     private String mRelatedGid = null;
-
+    
+    //此函数用于设置元数据信息，首先接受两个参数gid（字符串类型）和metainfo，gid是Goole任务的ID，metainfo是包含元数据信息的JSON对象。
     public void setMeta(String gid, JSONObject metaInfo) {
+        //在try-catch块中，首先使用put方法将gid添加到metainfo中，如果添加失败，会抛出JSONException异常，然后在catch块中通过日志输出错误信息。
         try {
             metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
+	  
         } catch (JSONException e) {
             Log.e(TAG, "failed to put related gid");
         }
+        //然后将metainfo转换为字符串并调用setNotes方法进行设置。
         setNotes(metaInfo.toString());
         setName(GTaskStringUtils.META_NOTE_NAME);
     }
 
+    //获取相关联的gid
     public String getRelatedGid() {
         return mRelatedGid;
     }
 
+    //判断当前数据是否为空，若为空则返回真值并保存。
     @Override
     public boolean isWorthSaving() {
         return getNotes() != null;
     }
-
+    
+    //这段代码是对note类中setContentByRemoteJSON的重写，作用是通过远程JSON数据设置笔记里的内容
     @Override
     public void setContentByRemoteJSON(JSONObject js) {
         super.setContentByRemoteJSON(js);
         if (getNotes() != null) {
+            //在 try-catch 块中，尝试从JSON对象中获取相关的任务 ID，并将其赋值给成员变量mRelatedGid，如果获取失败或者注释不是有效的 JSON 格式，则将 mRelatedGid 设为 null。
             try {
                 JSONObject metaInfo = new JSONObject(getNotes().trim());
                 mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
@@ -63,17 +76,20 @@ public class MetaData extends Task {
         }
     }
 
+    //函数作用是使用本地JSON数据对象设置元数据内容
     @Override
     public void setContentByLocalJSON(JSONObject js) {
         // this function should not be called
         throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
     }
 
+    //函数作用是从元数据内容中获取JSON对象
     @Override
     public JSONObject getLocalJSONFromContent() {
         throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
     }
-
+  
+    //函数作用是获取实时动作状态
     @Override
     public int getSyncAction(Cursor c) {
         throw new IllegalAccessError("MetaData:getSyncAction should not be called");

src/net/micode/notes/gtask/data/Node.java

@@ -20,30 +20,31 @@ import android.database.Cursor;
 
 import org.json.JSONObject;
 
+//下面是一些同步实时操作的基础数据类型，定义了指示相关操作的常量。
 public abstract class Node {
-    public static final int SYNC_ACTION_NONE = 0;
+    public static final int SYNC_ACTION_NONE = 0;//本地和云端都无可更新内容（即本地和云端内容一致）
 
-    public static final int SYNC_ACTION_ADD_REMOTE = 1;
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;//在云端增加内容
 
-    public static final int SYNC_ACTION_ADD_LOCAL = 2;
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;//在本地增加内容
 
-    public static final int SYNC_ACTION_DEL_REMOTE = 3;
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;//在云端删除内容
 
-    public static final int SYNC_ACTION_DEL_LOCAL = 4;
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;//在本地删除内容
 
-    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;//将本地内容更新到云端
 
-    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;//将云端内容更新到本地
 
-    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;//同步出现冲突
 
-    public static final int SYNC_ACTION_ERROR = 8;
+    public static final int SYNC_ACTION_ERROR = 8;//同步出现错误
 
     private String mGid;
 
     private String mName;
 
-    private long mLastModified;
+    private long mLastModified;//记录最后一次修改时间
 
     private boolean mDeleted;
 
@@ -54,46 +55,60 @@ public abstract class Node {
         mDeleted = false;
     }
 
+    //根据操作ID获取用于创建节点的 JSON 对象。
     public abstract JSONObject getCreateAction(int actionId);
 
+    //根据操作ID获取用于更新节点的 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);
 
+    //用于记录用于标识节点的ID
     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;
     }
 
+    //返回用于标识节点的ID
     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/net/micode/notes/gtask/data/SqlData.java

@@ -35,6 +35,7 @@ import org.json.JSONException;
 import org.json.JSONObject;
 
 
+//函数用于处理便签数据的数据库操作（得到类的简写名称并将其存入字符串TAG中）
 public class SqlData {
     private static final String TAG = SqlData.class.getSimpleName();
 
@@ -57,6 +58,7 @@ public class SqlData {
 
     private ContentResolver mContentResolver;
 
+    //判断是否直接用content生成，是则为true，否则为false
     private boolean mIsCreate;
 
     private long mDataId;
@@ -71,6 +73,7 @@ public class SqlData {
 
     private ContentValues mDiffDataValues;
 
+    //函数用于数据的初始化
     public SqlData(Context context) {
         mContentResolver = context.getContentResolver();
         mIsCreate = true;
@@ -82,6 +85,7 @@ public class SqlData {
         mDiffDataValues = new ContentValues();
     }
 
+    //函数用于数据的初始化
     public SqlData(Context context, Cursor c) {
         mContentResolver = context.getContentResolver();
         mIsCreate = false;
@@ -89,6 +93,7 @@ public class SqlData {
         mDiffDataValues = new ContentValues();
     }
 
+    //函数用于加载数据
     private void loadFromCursor(Cursor c) {
         mDataId = c.getLong(DATA_ID_COLUMN);
         mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@@ -97,7 +102,9 @@ public class SqlData {
         mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
     }
 
+    //函数用于设置共享的数据，并提供异常抛出与处理机制
     public void setContent(JSONObject js) throws JSONException {
+        //如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID
         long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
         if (mIsCreate || mDataId != dataId) {
             mDiffDataValues.put(DataColumns.ID, dataId);
@@ -130,11 +137,13 @@ public class SqlData {
         mDataContentData3 = dataContentData3;
     }
 
+    //函数用于获取共享的数据，并提供异常抛出与处理机制
     public JSONObject getContent() throws JSONException {
         if (mIsCreate) {
             Log.e(TAG, "it seems that we haven't created this in database yet");
             return null;
         }
+        //创建JSONObject对象，并将相关数据放入其中，并返回。
         JSONObject js = new JSONObject();
         js.put(DataColumns.ID, mDataId);
         js.put(DataColumns.MIME_TYPE, mDataMimeType);
@@ -144,6 +153,7 @@ public class SqlData {
         return js;
     }
 
+    //函数用于把当前所做的修改保存到数据库
     public void commit(long noteId, boolean validateVersion, long version) {
 
         if (mIsCreate) {
@@ -183,6 +193,7 @@ public class SqlData {
         mIsCreate = false;
     }
 
+    //函数用于获取当前id
     public long getId() {
         return mDataId;
     }

src/net/micode/notes/gtask/data/SqlNote.java

@@ -37,12 +37,13 @@ import org.json.JSONObject;
 
 import java.util.ArrayList;
 
-
+//函数用于将得到的类的简写名称存入字符串TAG中
 public class SqlNote {
     private static final String TAG = SqlNote.class.getSimpleName();
 
     private static final int INVALID_ID = -99999;
 
+    //集合了interface NoteColumns中的17个SF常量
     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,
@@ -86,6 +87,7 @@ public class SqlNote {
 
     public static final int VERSION_COLUMN = 16;
 
+    //下面定义了17个内部变量，其中12个可以在content中获得，5个需要初始化为0或new
     private Context mContext;
 
     private ContentResolver mContentResolver;
@@ -122,6 +124,7 @@ public class SqlNote {
 
     private ArrayList<SqlData> mDataList;
 
+    //构造函数，用于对所有的变量进行初始化
     public SqlNote(Context context) {
         mContext = context;
         mContentResolver = context.getContentResolver();
@@ -142,11 +145,14 @@ public class SqlNote {
         mDiffNoteValues = new ContentValues();
         mDataList = new ArrayList<SqlData>();
     }
-
+   
+    //构造函数
     public SqlNote(Context context, Cursor c) {
         mContext = context;
+        //获取内容解析器对象
         mContentResolver = context.getContentResolver();
         mIsCreate = false;
+        //从传入的Cursor对象中加载便签数据
         loadFromCursor(c);
         mDataList = new ArrayList<SqlData>();
         if (mType == Notes.TYPE_NOTE)
@@ -154,6 +160,7 @@ public class SqlNote {
         mDiffNoteValues = new ContentValues();
     }
 
+    //构造函数，用于标示构造方式
     public SqlNote(Context context, long id) {
         mContext = context;
         mContentResolver = context.getContentResolver();
@@ -163,16 +170,18 @@ public class SqlNote {
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
         mDiffNoteValues = new ContentValues();
-
     }
 
+    //函数作用于从数据库中加载指定ID的便签数据
     private void loadFromCursor(long id) {
         Cursor c = null;
+        //通过ID获得对应的ContentResolver中的cursor
         try {
             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
                     new String[] {
                         String.valueOf(id)
                     }, null);
+            //然后加载数据进行初始化
             if (c != null) {
                 c.moveToNext();
                 loadFromCursor(c);
@@ -185,6 +194,7 @@ public class SqlNote {
         }
     }
 
+    //函数用于从传入的Cursor对象中加载便签数据
     private void loadFromCursor(Cursor c) {
         mId = c.getLong(ID_COLUMN);
         mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@@ -200,9 +210,12 @@ public class SqlNote {
         mVersion = c.getLong(VERSION_COLUMN);
     }
 
+    //函数用于从数据库中加载与特定便签相关的数据内容
     private void loadDataContent() {
         Cursor c = null;
+        //清空mDatalist中的数据，以便重新加载新的数据
         mDataList.clear();
+        //使用内容解析器对象mContentResolver调用query()方法查询数据库，查询结果将赋值给Cursor对象c，再通过检查c是否为空来判断查询是否成功。如果不为空，表示查询到了结果。然后通过循环遍历c的每一行数据，创建SqlData对象并将其加入mDataList中。
         try {
             c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
                     "(note_id=?)", new String[] {
@@ -226,13 +239,16 @@ public class SqlNote {
         }
     }
 
+    //函数用于设置便签的内容，接收一个JSONObject对象作为参数，并根据该对象中的数据更新便签的属性。
     public boolean setContent(JSONObject js) {
         try {
+            //从JSONObject对象中获取名为note的子对象，该子对象包含了便签的各个属性。接着根据便签的类型（系统、文件夹、笔记）进行不同的处理逻辑。
             JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            //如果类型是系统，则打印警告信息
             if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
                 Log.w(TAG, "cannot set system folder");
             } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
-                // for folder we can only update the snnipet and type
+                // 如果类型是文件夹，则更新摘要和类型属性。如果是新建笔记或者摘要有变化，则将新的摘要值存入mDiffNoteValues集合，并更新mSnippet的值。同样的，如果是新建便签或者类型有变化，则将新的类型值存入mDiffNoteValues集合，并更新mType的值。
                 String snippet = note.has(NoteColumns.SNIPPET) ? note
                         .getString(NoteColumns.SNIPPET) : "";
                 if (mIsCreate || !mSnippet.equals(snippet)) {
@@ -246,7 +262,8 @@ public class SqlNote {
                     mDiffNoteValues.put(NoteColumns.TYPE, type);
                 }
                 mType = type;
-            } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+            } //如果类型是笔记，则根据笔记的各个属性更新相应的值
+	      else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
                 JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
                 long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
                 if (mIsCreate || mId != id) {
@@ -331,6 +348,7 @@ public class SqlNote {
                 }
                 mOriginParent = originParent;
 
+                //最后，遍历dataArray数组，该数组包含了便签的内容数据。对于每个数据对象，如果存在ID属性，就在mDataList列表中查找对应的SqlData对象，如果找到则使用该对象，否则创建一个新的SqlData对象并添加到mDataList列表中。然后调用sqlData.setContent(data)，将数据对象传递给SqlData对象进行处理。
                 for (int i = 0; i < dataArray.length(); i++) {
                     JSONObject data = dataArray.getJSONObject(i);
                     SqlData sqlData = null;
@@ -343,7 +361,7 @@ public class SqlNote {
                         }
                     }
 
-                    if (sqlData == null) {
+                    if (sqlData == null) {‘’
                         sqlData = new SqlData(mContext);
                         mDataList.add(sqlData);
                     }
@@ -359,16 +377,19 @@ public class SqlNote {
         return true;
     }
 
+    //函数用于获取便签的内容
     public JSONObject getContent() {
         try {
             JSONObject js = new JSONObject();
 
+            //如果mIsCreate属性为true，表示该便签还未在数据库中创建，此时打印警告信息并返回null
             if (mIsCreate) {
                 Log.e(TAG, "it seems that we haven't created this in database yet");
                 return null;
             }
 
             JSONObject note = new JSONObject();
+            //如果便签类型是笔记，将便签的各个属性添加到note对象中，然后将note对象添加到js对象中。同时创建一个名为dataArray的JSONArray数组，并遍历mDataList列表中的每个SqlData对象。对于每个SqlData对象，调用getContent获取其内容数据，并将数据对象添加到dataArray数组中。
             if (mType == Notes.TYPE_NOTE) {
                 note.put(NoteColumns.ID, mId);
                 note.put(NoteColumns.ALERTED_DATE, mAlertDate);
@@ -392,7 +413,7 @@ public class SqlNote {
                     }
                 }
                 js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
-            } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
+            } //如果类型是文件夹和系统，将ID、类型和摘要属性添加到note对象中，然后将note对象添加到js对象中。                  	      else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
                 note.put(NoteColumns.ID, mId);
                 note.put(NoteColumns.TYPE, mType);
                 note.put(NoteColumns.SNIPPET, mSnippet);
@@ -407,45 +428,56 @@ public class SqlNote {
         return null;
     }
 
+    //函数用于给当前ID设置父ID
     public void setParentId(long id) {
         mParentId = id;
         mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
     }
 
+    //函数用于给当前ID设置GTASK_ID,
     public void setGtaskId(String gid) {
         mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
     }
 
+    //函数用于给当前ID设置同步ID
     public void setSyncId(long syncId) {
         mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
     }
 
+    //函数用于初始化本地修改，即撤销所有当前修改
     public void resetLocalModified() {
         mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
     }
 
+    //函数用于获得当前ID
     public long getId() {
         return mId;
     }
 
+    //函数用于获得当前ID的父ID
     public long getParentId() {
         return mParentId;
     }
 
+    //函数用于显示当前便签的摘要
     public String getSnippet() {
         return mSnippet;
     }
 
+    //函数用于判断是否为笔记属性
     public boolean isNoteType() {
         return mType == Notes.TYPE_NOTE;
     }
 
+    //函数用于把对当前便签所做的修改保存到数据库中
     public void commit(boolean validateVersion) {
         if (mIsCreate) {
+            //如果便签的ID为无效值（INVALID_ID）且mDiffNoteValues集合中包含键为NoteColumns.ID的键值对，则将该键值对从集合中移除
             if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
                 mDiffNoteValues.remove(NoteColumns.ID);
             }
 
+            //调用ContentResolver的insert将便签的内容插入到数据库中
             Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
             try {
                 mId = Long.valueOf(uri.getPathSegments().get(1));
@@ -457,12 +489,14 @@ public class SqlNote {
                 throw new IllegalStateException("Create thread id failed");
             }
 
+            //如果便签类型为笔记，则遍历mDataList列表中的每个SqlData对象，并调用commit，将对应的数据保存到数据库中
             if (mType == Notes.TYPE_NOTE) {
                 for (SqlData sqlData : mDataList) {
                     sqlData.commit(mId, false, -1);
                 }
             }
         } else {
+            //如果便签的ID无效或为根文件夹或通话记录文件夹，则抛出IllegalStateException异常，提示正在尝试使用无效ID更新笔记
             if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
                 Log.e(TAG, "No such note");
                 throw new IllegalStateException("Try to update note with invalid id");
@@ -470,6 +504,7 @@ public class SqlNote {
             if (mDiffNoteValues.size() > 0) {
                 mVersion ++;
                 int result = 0;
+                //如果validateVersion值为false，则直接调用update更新内容到数据库中，否则先查询数据库中该便签的版本号，如果查询得到的版本号小于等于mVersion，则更新笔记到数据库中，否则抛出异常，提示提交失败
                 if (!validateVersion) {
                     result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
                             + NoteColumns.ID + "=?)", new String[] {
@@ -485,8 +520,9 @@ public class SqlNote {
                 if (result == 0) {
                     Log.w(TAG, "there is no update. maybe user updates note when syncing");
                 }
-            }
+            } 
-
+             
+            //如果便签类型为笔记，则遍历mDataList列表中的每个SqlData对象，调用commit，将对应的数据保存到数据库中
             if (mType == Notes.TYPE_NOTE) {
                 for (SqlData sqlData : mDataList) {
                     sqlData.commit(mId, validateVersion, mVersion);
@@ -495,10 +531,12 @@ public class SqlNote {
         }
 
         // refresh local info
+        //调用loadFromCursor重新加载从数据库中获取的数据，并调用loadDataContent重新加载便签的附加数据，以确保对便签修改的完整性和正确性
         loadFromCursor(mId);
         if (mType == Notes.TYPE_NOTE)
             loadDataContent();
 
+        //最后清空mDiffNoteValues集合，将mIsCreate属性设置为false，表示提交操作已完成
         mDiffNoteValues.clear();
         mIsCreate = false;
     }

src/net/micode/notes/gtask/data/TaskList.java

@@ -33,7 +33,7 @@ import java.util.ArrayList;
 public class TaskList extends Node {
     private static final String TAG = TaskList.class.getSimpleName();
 
-    private int mIndex;
+    private int mIndex;//当前TaskList的指针
 
     private ArrayList<Task> mChildren;
 
@@ -43,6 +43,7 @@ public class TaskList extends Node {
         mIndex = 1;
     }
 
+    //生成并返回一个半酣了一定数据的JSONObject实体
     public JSONObject getCreateAction(int actionId) {
         JSONObject js = new JSONObject();
 
@@ -74,6 +75,7 @@ public class TaskList extends Node {
         return js;
     }
 
+    //更新JSONObject实体
     public JSONObject getUpdateAction(int actionId) {
         JSONObject js = new JSONObject();
 
@@ -103,6 +105,7 @@ public class TaskList extends Node {
         return js;
     }
 
+    //通过远程JSON对象实现远程同步
     public void setContentByRemoteJSON(JSONObject js) {
         if (js != null) {
             try {
@@ -129,6 +132,7 @@ public class TaskList extends Node {
         }
     }
 
+    //通过本地JSON对象实现本地同步
     public void setContentByLocalJSON(JSONObject js) {
         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
             Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
@@ -157,6 +161,7 @@ public class TaskList extends Node {
         }
     }
 
+    //将本地内容转换为JSONObject
     public JSONObject getLocalJSONFromContent() {
         try {
             JSONObject js = new JSONObject();
@@ -183,6 +188,7 @@ public class TaskList extends Node {
         }
     }
 
+    //提供同步任务，确定同步操作的类型。   
     public int getSyncAction(Cursor c) {
         try {
             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
@@ -220,6 +226,7 @@ public class TaskList extends Node {
         return mChildren.size();
     }
 
+    //在当前任务表末尾添加新的任务
     public boolean addChildTask(Task task) {
         boolean ret = false;
         if (task != null && !mChildren.contains(task)) {
@@ -234,6 +241,7 @@ public class TaskList extends Node {
         return ret;
     }
 
+    //在当前任务表的指定位置添加新的任务
     public boolean addChildTask(Task task, int index) {
         if (index < 0 || index > mChildren.size()) {
             Log.e(TAG, "add child task: invalid index");
@@ -260,6 +268,7 @@ public class TaskList extends Node {
         return true;
     }
 
+    //删除任务表中的一个任务
     public boolean removeChildTask(Task task) {
         boolean ret = false;
         int index = mChildren.indexOf(task);
@@ -281,6 +290,7 @@ public class TaskList extends Node {
         return ret;
     }
 
+    //移动任务表中的一个任务
     public boolean moveChildTask(Task task, int index) {
 
         if (index < 0 || index >= mChildren.size()) {
@@ -299,6 +309,7 @@ public class TaskList extends Node {
         return (removeChildTask(task) && addChildTask(task, index));
     }
 
+    //寻找一个任务
     public Task findChildTaskByGid(String gid) {
         for (int i = 0; i < mChildren.size(); i++) {
             Task t = mChildren.get(i);
@@ -309,10 +320,12 @@ public class TaskList extends Node {
         return null;
     }
 
+    //返指定index的任务
     public int getChildTaskIndex(Task task) {
         return mChildren.indexOf(task);
     }
 
+   //返回指定index的任务
     public Task getChildTaskByIndex(int index) {
         if (index < 0 || index >= mChildren.size()) {
             Log.e(TAG, "getTaskByIndex: invalid index");
@@ -320,7 +333,8 @@ public class TaskList extends Node {
         }
         return mChildren.get(index);
     }
-
+  
+    //返回指定gid的任务
     public Task getChilTaskByGid(String gid) {
         for (Task task : mChildren) {
             if (task.getGid().equals(gid))

src/net/micode/notes/gtask/remote/GTaskASyncTask.java

@@ -28,7 +28,7 @@ import net.micode.notes.R;
 import net.micode.notes.ui.NotesListActivity;
 import net.micode.notes.ui.NotesPreferenceActivity;
 
-
+//异步操作类，实现GTask的异步操作过程
 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
 
     private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
@@ -62,7 +62,8 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
             message
         });
     }
-
+    
+    //向用户提示当前同步的状态
     private void showNotification(int tickerId, String content) {
         Notification notification = new Notification(R.drawable.notification, mContext
                 .getString(tickerId), System.currentTimeMillis());
@@ -71,22 +72,23 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         PendingIntent pendingIntent;
         if (tickerId != R.string.ticker_success) {
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
-                    NotesPreferenceActivity.class), 0);
+                    NotesPreferenceActivity.class), 0); //如果同步不成功，那么从系统取得一个用于启动一个NotesPreferenceActivity的PendingIntent对象
 
         } else {
             pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
-                    NotesListActivity.class), 0);
+                    NotesListActivity.class), 0); //如果同步成功，那么从系统取得一个用于启动一个NotesListActivity的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)));
+                .getSyncAccountName(mContext)));//利用getString,将把 NotesPreferenceActivity.getSyncAccountName(mContext))的字符串内容传进sync_progress_login中
-        return mTaskManager.sync(mContext, this);
+        return mTaskManager.sync(mContext, this);  //进行后台同步具体操作
     }
 
     @Override
@@ -98,7 +100,7 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
     }
 
     @Override
-    protected void onPostExecute(Integer result) {
+    protected void onPostExecute(Integer result) { //用于在执行完后台任务后更新UI,显示结果
         if (result == GTaskManager.STATE_SUCCESS) {
             showNotification(R.string.ticker_success, mContext.getString(
                     R.string.success_sync_account, mTaskManager.getSyncAccount()));
@@ -110,11 +112,11 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         } else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
             showNotification(R.string.ticker_cancel, mContext
                     .getString(R.string.error_sync_cancelled));
-        }
+        }//几种不同情况下的结果显示
         if (mOnCompleteListener != null) {
             new Thread(new Runnable() {
 
-                public void run() {
+                public void run() {//完成后的操作，使用onComplete()将所有值都重新初始化，相当于完成一次操作
                     mOnCompleteListener.onComplete();
                 }
             }).start();

src/net/micode/notes/gtask/remote/GTaskSyncService.java

@@ -42,6 +42,7 @@ public class GTaskSyncService extends Service {
 
     private static String mSyncProgress = "";
 
+    //开始一个同步的工作
     private void startSync() {
         if (mSyncTask == null) {
             mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@@ -52,10 +53,11 @@ public class GTaskSyncService extends Service {
                 }
             });
             sendBroadcast("");
-            mSyncTask.execute();
+            mSyncTask.execute(); ////这个函数让任务是以单线程队列方式或线程池队列方式运行
         }
     }
 
+    //取消同步
     private void cancelSync() {
         if (mSyncTask != null) {
             mSyncTask.cancelSync();
@@ -72,6 +74,7 @@ public class GTaskSyncService extends Service {
         Bundle bundle = intent.getExtras();
         if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
             switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
+             //两种情况，开始同步或者取消同步
                 case ACTION_START_SYNC:
                     startSync();
                     break;
@@ -86,6 +89,7 @@ public class GTaskSyncService extends Service {
         return super.onStartCommand(intent, flags, startId);
     }
 
+    //在没有内存的情况下如果存在service则结束掉service
     @Override
     public void onLowMemory() {
         if (mSyncTask != null) {
@@ -97,31 +101,36 @@ public class GTaskSyncService extends Service {
         return null;
     }
 
+    //发送同步的相关通知
     public void sendBroadcast(String msg) {
         mSyncProgress = msg;
-        Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
+        Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME); //创建一个新的Intent
         intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null);
         intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
         sendBroadcast(intent);
     }
 
+    //执行开始同步的操作
     public static void startSync(Activity activity) {
         GTaskManager.getInstance().setActivityContext(activity);
         Intent intent = new Intent(activity, GTaskSyncService.class);
         intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
         activity.startService(intent);
     }
-
+ 
+    //执行取消同步的操作
     public static void cancelSync(Context context) {
         Intent intent = new Intent(context, GTaskSyncService.class);
         intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
         context.startService(intent);
     }
 
+    //判断是否在进行同步
     public static boolean isSyncing() {
         return mSyncTask != null;
     }
 
+    //获取当前进度的信息
     public static String getProgressString() {
         return mSyncProgress;
     }