完成"GTaskASyncTask.java""GTaskClient.java""GTaskManager.java"阅读

Notes-master/app/build/intermediates/incremental/packageDebug/tmp/debug/dex-renamer-state.txt

@@ -1,4 +1,4 @@
-#Sun May 14 14:29:57 CST 2023
+#Tue May 16 12:28:11 CST 2023
 base.0=/Users/mac/AndroidStudioProjects/Notes-master/app/build/intermediates/dex/debug/mergeDexDebug/classes.dex
 path.0=classes.dex
 renamed.0=classes.dex

Notes-master/app/src/main/java/net/micode/notes/gtask/remote/GTaskASyncTask.java

@@ -29,6 +29,14 @@ import net.micode.notes.ui.NotesListActivity;
 import net.micode.notes.ui.NotesPreferenceActivity;
 
 
+/*异步操作类，实现GTask的异步操作过程
+ * 主要方法：
+ * private void showNotification(int tickerId, String content) 向用户提示当前同步的状态，是一个用于交互的方法
+ * protected Integer doInBackground(Void... unused) 此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间
+ * protected void onProgressUpdate(String... progress)  可以使用进度条增加用户体验度。 此方法在主线程执行，用于显示任务执行的进度。
+ * protected void onPostExecute(Integer result)  相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的结果处理操作UI
+ */
+
 public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
 
     private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
@@ -57,7 +65,8 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
         mTaskManager.cancelSync();
     }
 
-    public void publishProgess(String message) {
+    public void publishProgess(String message) {// 发布进度单位，系统将会调用onProgressUpdate()方法更新这些值
+
         publishProgress(new String[] {
             message
         });
@@ -92,24 +101,24 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
     @Override
     protected Integer doInBackground(Void... unused) {
         publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
-                .getSyncAccountName(mContext)));
-        return mTaskManager.sync(mContext, this);
+                .getSyncAccountName(mContext)));  //利用getString,将把 NotesPreferenceActivity.getSyncAccountName(mContext))的字符串内容传进sync_progress_login中
+        return mTaskManager.sync(mContext, this);    //进行后台同步具体操作
     }
 
     @Override
     protected void onProgressUpdate(String... progress) {
         showNotification(R.string.ticker_syncing, progress[0]);
-        if (mContext instanceof GTaskSyncService) {
+        if (mContext instanceof GTaskSyncService) {  //instanceof 判断mContext是否是GTaskSyncService的实例
             ((GTaskSyncService) mContext).sendBroadcast(progress[0]);
         }
     }
 
     @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()));
-            NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis());
+            NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis());  //设置最新同步的时间
         } 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) {
@@ -117,11 +126,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() {
+            new Thread(new Runnable() {  //这里好像是方法内的一个线程，但是并不太懂什么意思
 
-                public void run() {
+                public void run() {   //完成后的操作，使用onComplete()将所有值都重新初始化，相当于完成一次操作
                     mOnCompleteListener.onComplete();
                 }
             }).start();

Notes-master/app/src/main/java/net/micode/notes/gtask/remote/GTaskClient.java

@@ -61,10 +61,14 @@ import java.util.zip.Inflater;
 import java.util.zip.InflaterInputStream;
 
 
+/*
+ * 主要功能：实现GTASK的登录操作，进行GTASK任务的创建，创建任务列表，从网络上获取任务和任务列表的内容
+ * 主要使用类或技术：accountManager JSONObject HttpParams authToken Gid
+ */
 public class GTaskClient {
     private static final String TAG = GTaskClient.class.getSimpleName();
 
-    private static final String GTASK_URL = "https://mail.google.com/tasks/";
+    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";
 
@@ -102,6 +106,10 @@ public class GTaskClient {
         mUpdateArray = null;
     }
 
+    /*用来获取的实例化对象
+     * 使用 getInstance()
+     * 返回mInstance这个实例化对象
+     */
     public static synchronized GTaskClient getInstance() {
         if (mInstance == null) {
             mInstance = new GTaskClient();
@@ -109,42 +117,49 @@ public class GTaskClient {
         return mInstance;
     }
 
+    /*用来实现登录操作的函数，传入的参数是一个Activity
+     * 设置登录操作限制时间，如果超时则需要重新登录
+     * 有两种登录方式，使用用户自己的URL登录或者使用谷歌官方的URL登录
+     * 返回true或者false，即最后是否登陆成功
+     */
     public boolean login(Activity activity) {
         // we suppose that the cookie would expire after 5 minutes
         // then we need to re-login
+        //判断距离最后一次登录操作是否超过5分钟
         final long interval = 1000 * 60 * 5;
         if (mLastLoginTime + interval < System.currentTimeMillis()) {
             mLoggedin = false;
         }
 
-        // need to re-login after account switch
+        // need to re-login after account switch  重新登录操作
         if (mLoggedin
                 && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
                         .getSyncAccountName(activity))) {
             mLoggedin = false;
         }
-
+        //如果没有超过时间，则不需要重新登录
         if (mLoggedin) {
             Log.d(TAG, "already logged in");
             return true;
         }
 
-        mLastLoginTime = System.currentTimeMillis();
-        String authToken = loginGoogleAccount(activity, false);
+        mLastLoginTime = System.currentTimeMillis();//更新最后登录时间，改为系统当前时间
+        String authToken = loginGoogleAccount(activity, false);//判断是否登录到谷歌账户
         if (authToken == null) {
             Log.e(TAG, "login google account failed");
             return false;
         }
 
         // login with custom domain if necessary
-        if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
+        //尝试使用用户自己的域名登录
+        if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()//将用户账号名改为统一格式（小写）后判断是否为谷歌账号地址
                 .endsWith("googlemail.com"))) {
             StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
             int index = mAccount.name.indexOf('@') + 1;
             String suffix = mAccount.name.substring(index);
             url.append(suffix + "/");
-            mGetUrl = url.toString() + "ig";
-            mPostUrl = url.toString() + "r/ig";
+            mGetUrl = url.toString() + "ig";//设置用户对应的getUrl
+            mPostUrl = url.toString() + "r/ig";//设置用户对应的postUrl
 
             if (tryToLoginGtask(activity, authToken)) {
                 mLoggedin = true;
@@ -152,6 +167,7 @@ public class GTaskClient {
         }
 
         // try to login with google official url
+        //如果用户账户无法登录，则使用谷歌官方的URI进行登录
         if (!mLoggedin) {
             mGetUrl = GTASK_GET_URL;
             mPostUrl = GTASK_POST_URL;
@@ -164,10 +180,15 @@ public class GTaskClient {
         return true;
     }
 
+    /*具体实现登录谷歌账户的方法
+     * 使用令牌机制
+     * 使用AccountManager来管理注册账号
+     * 返回值是账号的令牌
+     */
     private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
-        String authToken;
-        AccountManager accountManager = AccountManager.get(activity);
-        Account[] accounts = accountManager.getAccountsByType("com.google");
+        String authToken;//令牌，是登录操作保证安全性的一个方法
+        AccountManager accountManager = AccountManager.get(activity);//AccountManager这个类给用户提供了集中注册账号的接口
+        Account[] accounts = accountManager.getAccountsByType("com.google");//获取全部以com.google结尾的account
 
         if (accounts.length == 0) {
             Log.e(TAG, "there is no available google account");
@@ -176,6 +197,7 @@ public class GTaskClient {
 
         String accountName = NotesPreferenceActivity.getSyncAccountName(activity);
         Account account = null;
+        //遍历获得的accounts信息，寻找已经记录过的账户信息
         for (Account a : accounts) {
             if (a.name.equals(accountName)) {
                 account = a;
@@ -190,11 +212,13 @@ public class GTaskClient {
         }
 
         // get the token now
+        //获取选中账号的令牌
         AccountManagerFuture<Bundle> accountManagerFuture = accountManager.getAuthToken(account,
                 "goanna_mobile", null, activity, null, null);
         try {
             Bundle authTokenBundle = accountManagerFuture.getResult();
             authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN);
+            //如果是invalidateToken，那么需要调用invalidateAuthToken(String, String)方法废除这个无效token
             if (invalidateToken) {
                 accountManager.invalidateAuthToken("com.google", authToken);
                 loginGoogleAccount(activity, false);
@@ -206,11 +230,12 @@ public class GTaskClient {
 
         return authToken;
     }
-
+    //尝试登陆Gtask，这只是一个预先判断令牌是否是有效以及是否能登上GTask的方法,而不是具体实现登陆的方法
     private boolean tryToLoginGtask(Activity activity, String authToken) {
         if (!loginGtask(authToken)) {
             // maybe the auth token is out of date, now let's invalidate the
             // token and try again
+            //删除过一个无效的authToken，申请一个新的后再次尝试登陆
             authToken = loginGoogleAccount(activity, true);
             if (authToken == null) {
                 Log.e(TAG, "login google account failed");
@@ -225,25 +250,27 @@ public class GTaskClient {
         return true;
     }
 
+    //实现登录GTask的具体操作
     private boolean loginGtask(String authToken) {
         int timeoutConnection = 10000;
-        int timeoutSocket = 15000;
-        HttpParams httpParameters = new BasicHttpParams();
-        HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
-        HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
+        int timeoutSocket = 15000;  //socket是一种通信连接实现数据的交换的端口
+        HttpParams httpParameters = new BasicHttpParams(); //实例化一个新的HTTP参数类
+        HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);//设置连接超时时间
+        HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);//设置设置端口超时时间
         mHttpClient = new DefaultHttpClient(httpParameters);
-        BasicCookieStore localBasicCookieStore = new BasicCookieStore();
+        BasicCookieStore localBasicCookieStore = new BasicCookieStore(); //设置本地cookie
         mHttpClient.setCookieStore(localBasicCookieStore);
         HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
 
         // login gtask
         try {
-            String loginUrl = mGetUrl + "?auth=" + authToken;
-            HttpGet httpGet = new HttpGet(loginUrl);
+            String loginUrl = mGetUrl + "?auth=" + authToken;  //设置登录的url
+            HttpGet httpGet = new HttpGet(loginUrl);  //通过登录的uri实例化网页上资源的查找
             HttpResponse response = null;
             response = mHttpClient.execute(httpGet);
 
             // get the cookie now
+            //获取CookieStore里存放的cookie,看如果存有“GTL(不知道什么意思)”，则说明有验证成功的有效的cookie
             List<Cookie> cookies = mHttpClient.getCookieStore().getCookies();
             boolean hasAuthCookie = false;
             for (Cookie cookie : cookies) {
@@ -256,6 +283,7 @@ public class GTaskClient {
             }
 
             // get the client version
+            //获取client的内容，具体操作是在返回的Content中截取从_setup(开始到)}</script>中间的字符串内容，也就是gtask_url的内容
             String resString = getResponseContent(response.getEntity());
             String jsBegin = "_setup(";
             String jsEnd = ")}</script>";
@@ -284,6 +312,10 @@ public class GTaskClient {
         return mActionId++;
     }
 
+    /*实例化创建一个用于向网络传输数据的对象
+     * 使用HttpPost类
+     * 返回一个httpPost实例化对象，但里面还没有内容
+     */
     private HttpPost createHttpPost() {
         HttpPost httpPost = new HttpPost(mPostUrl);
         httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
@@ -291,24 +323,28 @@ public class GTaskClient {
         return httpPost;
     }
 
+    /*通过URL获取响应后返回的数据，也就是网络上的数据和资源
+     * 使用getContentEncoding()获取网络上的资源和数据
+     * 返回值就是获取到的资源
+     */
     private String getResponseContent(HttpEntity entity) throws IOException {
         String contentEncoding = null;
-        if (entity.getContentEncoding() != null) {
+        if (entity.getContentEncoding() != null) {//通过URL得到HttpEntity对象，如果不为空则使用getContent（）方法创建一个流将数据从网络都过来
             contentEncoding = entity.getContentEncoding().getValue();
             Log.d(TAG, "encoding: " + contentEncoding);
         }
 
         InputStream input = entity.getContent();
-        if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {
+        if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {//GZIP是使用DEFLATE进行压缩数据的另一个压缩库
             input = new GZIPInputStream(entity.getContent());
-        } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {
+        } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {//DEFLATE是一个无专利的压缩算法，它可以实现无损数据压缩
             Inflater inflater = new Inflater(true);
             input = new InflaterInputStream(entity.getContent(), inflater);
         }
 
         try {
             InputStreamReader isr = new InputStreamReader(input);
-            BufferedReader br = new BufferedReader(isr);
+            BufferedReader br = new BufferedReader(isr);//是一个包装类，它可以包装字符流，将字符流放入缓存里，先把字符读到缓存里，到缓存满了时候，再读入内存，是为了提供读的效率而设计的
             StringBuilder sb = new StringBuilder();
 
             while (true) {
@@ -323,20 +359,28 @@ public class GTaskClient {
         }
     }
 
+    /*通过JSON发送请求
+     * 请求的具体内容在json的实例化对象js中然后传入
+     * 利用UrlEncodedFormEntity entity和httpPost.setEntity(entity)方法把js中的内容放置到httpPost中
+     * 执行请求后使用getResponseContent方法得到返回的数据和资源
+     * 将资源再次放入json后返回
+     */
     private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
-        if (!mLoggedin) {
+        if (!mLoggedin) {//未登录
             Log.e(TAG, "please login first");
             throw new ActionFailureException("not logged in");
         }
 
+        //实例化一个httpPost的对象用来向服务器传输数据，在这里就是发送请求，而请求的内容在js里
         HttpPost httpPost = createHttpPost();
         try {
             LinkedList<BasicNameValuePair> list = new LinkedList<BasicNameValuePair>();
             list.add(new BasicNameValuePair("r", js.toString()));
-            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8");
+            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8"); //UrlEncodedFormEntity()的形式比较单一，是普通的键值对
             httpPost.setEntity(entity);
 
             // execute the post
+            //执行这个请求
             HttpResponse response = mHttpClient.execute(httpPost);
             String jsString = getResponseContent(response.getEntity());
             return new JSONObject(jsString);
@@ -360,6 +404,12 @@ public class GTaskClient {
         }
     }
 
+    /*创建单个任务
+     * 传入参数是一个.gtask.data.Task包里Task类的对象
+     * 利用json获取Task里的内容,并且创建相应的jsPost
+     * 利用postRequest得到任务的返回信息
+     * 使用task.setGid设置task的new_ID
+     */
     public void createTask(Task task) throws NetworkFailureException {
         commitUpdate();
         try {
@@ -386,6 +436,9 @@ public class GTaskClient {
         }
     }
 
+    /*
+     * 创建一个任务列表，与createTask几乎一样，区别就是最后设置的是tasklist的gid
+     */
     public void createTaskList(TaskList tasklist) throws NetworkFailureException {
         commitUpdate();
         try {
@@ -412,6 +465,11 @@ public class GTaskClient {
         }
     }
 
+    /*
+     * 同步更新操作
+     * 使用JSONObject进行数据存储，使用jsPost.put，Put的信息包括UpdateArray和ClientVersion
+     * 使用postRequest发送这个jspost,进行处理
+     */
     public void commitUpdate() throws NetworkFailureException {
         if (mUpdateArray != null) {
             try {
@@ -433,6 +491,10 @@ public class GTaskClient {
         }
     }
 
+    /*
+     * 添加更新的事项
+     * 调用commitUpdate()实现
+     */
     public void addUpdateNode(Node node) throws NetworkFailureException {
         if (node != null) {
             // too many update items may result in an error
@@ -447,6 +509,12 @@ public class GTaskClient {
         }
     }
 
+    /*
+     * 移动task,比如讲task移动到不同的task列表中去
+     * 通过getGid获取task所属列表的gid
+     * 通过JSONObject.put(String name, Object value)函数设置移动后的task的相关属性值，从而达到移动的目的
+     * 最后还是通过postRequest进行更新后的发送
+     */
     public void moveTask(Task task, TaskList preParent, TaskList curParent)
             throws NetworkFailureException {
         commitUpdate();
@@ -463,15 +531,17 @@ public class GTaskClient {
             if (preParent == curParent && task.getPriorSibling() != null) {
                 // put prioring_sibing_id only if moving within the tasklist and
                 // it is not the first one
+                //设置优先级ID，只有当移动是发生在文件中
                 action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling());
             }
-            action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid());
-            action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid());
+            action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid());  //设置移动前所属列表
+            action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid());  //设置当前所属列表
             if (preParent != curParent) {
                 // put the dest_list only if moving between tasklists
                 action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
             }
             actionList.put(action);
+            //最后将ACTION_LIST加入到jsPost中
             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
 
             // client_version
@@ -486,6 +556,11 @@ public class GTaskClient {
         }
     }
 
+    /*
+     * 删除操作节点
+     * 还是利用JSON
+     * 删除过后使用postRequest发送删除后的结果
+     */
     public void deleteNode(Node node) throws NetworkFailureException {
         commitUpdate();
         try {
@@ -494,7 +569,7 @@ public class GTaskClient {
 
             // action_list
             node.setDeleted(true);
-            actionList.put(node.getUpdateAction(getActionId()));
+            actionList.put(node.getUpdateAction(getActionId()));  //这里会获取到删除操作的ID，加入到actionLiast中
             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
 
             // client_version
@@ -509,6 +584,11 @@ public class GTaskClient {
         }
     }
 
+    /*
+     * 获取任务列表
+     * 首先通过GetURI使用getResponseContent从网上获取数据
+     * 然后筛选出"_setup("到)}</script>的部分，并且从中获取GTASK_JSON_LISTS的内容返回
+     */
     public JSONArray getTaskLists() throws NetworkFailureException {
         if (!mLoggedin) {
             Log.e(TAG, "please login first");
@@ -521,6 +601,7 @@ public class GTaskClient {
             response = mHttpClient.execute(httpGet);
 
             // get the task list
+            //筛选工作，把筛选出的字符串放入jsString
             String resString = getResponseContent(response.getEntity());
             String jsBegin = "_setup(";
             String jsEnd = ")}</script>";
@@ -531,6 +612,7 @@ public class GTaskClient {
                 jsString = resString.substring(begin + jsBegin.length(), end);
             }
             JSONObject js = new JSONObject(jsString);
+            //获取GTASK_JSON_LISTS
             return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS);
         } catch (ClientProtocolException e) {
             Log.e(TAG, e.toString());
@@ -547,6 +629,9 @@ public class GTaskClient {
         }
     }
 
+    /*
+     * 通过传入的TASKList的gid,从网络上获取相应属于这个任务列表的任务
+     */
     public JSONArray getTaskList(String listGid) throws NetworkFailureException {
         commitUpdate();
         try {
@@ -558,7 +643,7 @@ public class GTaskClient {
             action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL);
             action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
-            action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid);
+            action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid);    //这里设置为传入的listGid
             action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false);
             actionList.put(action);
             jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
@@ -579,7 +664,8 @@ public class GTaskClient {
         return mAccount;
     }
 
+    //重置更新的内容
     public void resetUpdateArray() {
         mUpdateArray = null;
     }
-}
+}

Notes-master/app/src/main/java/net/micode/notes/gtask/remote/GTaskManager.java

@@ -50,70 +50,72 @@ import java.util.Map;
 
 public class GTaskManager {
     private static final String TAG = GTaskManager.class.getSimpleName();
-
     public static final int STATE_SUCCESS = 0;
-
     public static final int STATE_NETWORK_ERROR = 1;
-
     public static final int STATE_INTERNAL_ERROR = 2;
-
     public static final int STATE_SYNC_IN_PROGRESS = 3;
-
     public static final int STATE_SYNC_CANCELLED = 4;
-
     private static GTaskManager mInstance = null;
 
     private Activity mActivity;
-
     private Context mContext;
-
     private ContentResolver mContentResolver;
-
     private boolean mSyncing;
-
     private boolean mCancelled;
-
     private HashMap<String, TaskList> mGTaskListHashMap;
-
     private HashMap<String, Node> mGTaskHashMap;
-
     private HashMap<String, MetaData> mMetaHashMap;
-
     private TaskList mMetaList;
-
     private HashSet<Long> mLocalDeleteIdMap;
-
     private HashMap<String, Long> mGidToNid;
-
     private HashMap<Long, String> mNidToGid;
 
-    private GTaskManager() {
-        mSyncing = false;
-        mCancelled = false;
-        mGTaskListHashMap = new HashMap<String, TaskList>();
+    private GTaskManager() {                                   //对象初始化函数
+        mSyncing = false;                                      //正在同步,flase代表未执行
+        mCancelled = false;                                    //全局标识，flase代表可以执行
+        mGTaskListHashMap = new HashMap<String, TaskList>();   //<>代表Java的泛型,就是创建一个用类型作为参数的类。
         mGTaskHashMap = new HashMap<String, Node>();
         mMetaHashMap = new HashMap<String, MetaData>();
         mMetaList = null;
         mLocalDeleteIdMap = new HashSet<Long>();
-        mGidToNid = new HashMap<String, Long>();
-        mNidToGid = new HashMap<Long, String>();
+        mGidToNid = new HashMap<String, Long>();    //GoogleID to NodeID??
+        mNidToGid = new HashMap<Long, String>();    //NodeID to GoogleID???通过hashmap散列表建立映射
     }
 
-    public static synchronized GTaskManager getInstance() {
+    /**
+     * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
+     * 功能：类初始化函数
+     * @author TTS
+     * @return GtaskManger
+     */
+    public static synchronized GTaskManager getInstance() {    //可能运行在多线程环境下，使用语言级同步--synchronized
         if (mInstance == null) {
             mInstance = new GTaskManager();
         }
         return mInstance;
     }
 
+    /**
+     * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
+     * @author TTS
+     * @param activity
+     */
     public synchronized void setActivityContext(Activity activity) {
-        // used for getting authtoken
+        // used for getting auth token
         mActivity = activity;
     }
 
-    public int sync(Context context, GTaskASyncTask asyncTask) {
+    /**
+     * 核心函数
+     * 功能：实现了本地同步操作和远端同步操作
+     * @author TTS
+     * @param context-----获取上下文
+     * @param asyncTask-------用于同步的异步操作类
+     * @return int
+     */
+    public int sync(Context context, GTaskASyncTask asyncTask) {           //核心函数
         if (mSyncing) {
-            Log.d(TAG, "Sync is in progress");
+            Log.d(TAG, "Sync is in progress");                       //创建日志文件（调试信息），debug
             return STATE_SYNC_IN_PROGRESS;
         }
         mContext = context;
@@ -128,8 +130,8 @@ public class GTaskManager {
         mNidToGid.clear();
 
         try {
-            GTaskClient client = GTaskClient.getInstance();
-            client.resetUpdateArray();
+            GTaskClient client = GTaskClient.getInstance();    //getInstance即为创建一个实例,client--客户机
+            client.resetUpdateArray();     //JSONArray类型，reset即置为NULL
 
             // login google task
             if (!mCancelled) {
@@ -140,15 +142,15 @@ public class GTaskManager {
 
             // get the task list from google
             asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
-            initGTaskList();
+            initGTaskList();                                 //获取Google上的JSONtasklist转为本地TaskList
 
             // do content sync work
             asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
             syncContent();
-        } catch (NetworkFailureException e) {
-            Log.e(TAG, e.toString());
+        } catch (NetworkFailureException e) {                       //分为两种异常，此类异常为网络异常
+            Log.e(TAG, e.toString());                             //创建日志文件（调试信息），error
             return STATE_NETWORK_ERROR;
-        } catch (ActionFailureException e) {
+        } catch (ActionFailureException e) {                        //此类异常为操作异常
             Log.e(TAG, e.toString());
             return STATE_INTERNAL_ERROR;
         } catch (Exception e) {
@@ -168,32 +170,41 @@ public class GTaskManager {
         return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
     }
 
+    /**
+     *功能：初始化GtaskList，获取Google上的JSONtasklist转为本地TaskList。
+     *获得的数据存储在mMetaList，mGTaskListHashMap，mGTaskHashMap
+     *@author TTS
+     *@exception NetworkFailureException
+     *@return void
+     */
     private void initGTaskList() throws NetworkFailureException {
         if (mCancelled)
             return;
-        GTaskClient client = GTaskClient.getInstance();
+        GTaskClient client = GTaskClient.getInstance();    //getInstance即为创建一个实例，client应指远端客户机
         try {
-            JSONArray jsTaskLists = client.getTaskLists();
+            //Json对象是Name Value对(即子元素)的无序集合，相当于一个Map对象。JsonObject类是bantouyan-json库对Json对象的抽象，提供操纵Json对象的各种方法。
+            //其格式为{"key1":value1,"key2",value2....};key 必须是字符串。
+            //因为ajax请求不刷新页面，但配合js可以实现局部刷新，因此json常常被用来作为异步请求的返回对象使用。
+            JSONArray jsTaskLists = client.getTaskLists();     //原注释为get task list------lists？？？
 
             // init meta list first
-            mMetaList = null;
+            mMetaList = null;                                       //TaskList类型
             for (int i = 0; i < jsTaskLists.length(); i++) {
-                JSONObject object = jsTaskLists.getJSONObject(i);
+                JSONObject object = jsTaskLists.getJSONObject(i);  //JSONObject与JSONArray一个为对象，一个为数组。此处取出单个JASONObject
                 String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
                 String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
 
-                if (name
-                        .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
-                    mMetaList = new TaskList();
-                    mMetaList.setContentByRemoteJSON(object);
+                if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
+                    mMetaList = new TaskList();                    //MetaList意为元表,Tasklist类型，此处为初始化
+                    mMetaList.setContentByRemoteJSON(object);      //将JSON中部分数据复制到自己定义的对象中相对应的数据：name->mname...
 
                     // load meta data
-                    JSONArray jsMetas = client.getTaskList(gid);
+                    JSONArray jsMetas = client.getTaskList(gid);   //原注释为get action_list------list？？？
                     for (int j = 0; j < jsMetas.length(); j++) {
                         object = (JSONObject) jsMetas.getJSONObject(j);
-                        MetaData metaData = new MetaData();
+                        MetaData metaData = new MetaData();            //继承自Node
                         metaData.setContentByRemoteJSON(object);
-                        if (metaData.isWorthSaving()) {
+                        if (metaData.isWorthSaving()) {                             //if not worth to save，metadata将不加入mMetaList
                             mMetaList.addChildTask(metaData);
                             if (metaData.getGid() != null) {
                                 mMetaHashMap.put(metaData.getRelatedGid(), metaData);
@@ -214,16 +225,16 @@ public class GTaskManager {
             // init task list
             for (int i = 0; i < jsTaskLists.length(); i++) {
                 JSONObject object = jsTaskLists.getJSONObject(i);
-                String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+                String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);  //通过getString函数传入本地某个标志数据的名称，获取其在远端的名称。
                 String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
 
                 if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)
                         && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
-                                + GTaskStringUtils.FOLDER_META)) {
-                    TaskList tasklist = new TaskList();
+                        + GTaskStringUtils.FOLDER_META)) {
+                    TaskList tasklist = new TaskList();     //继承自Node
                     tasklist.setContentByRemoteJSON(object);
                     mGTaskListHashMap.put(gid, tasklist);
-                    mGTaskHashMap.put(gid, tasklist);
+                    mGTaskHashMap.put(gid, tasklist);          //为什么加两遍？？？
 
                     // load tasks
                     JSONArray jsTasks = client.getTaskList(gid);
@@ -247,13 +258,18 @@ public class GTaskManager {
         }
     }
 
-    private void syncContent() throws NetworkFailureException {
+    /**
+     * 功能：本地内容同步操作
+     * @throws NetworkFailureException
+     * @return 无返回值
+     */
+    private void syncContent() throws NetworkFailureException {    //本地内容同步操作
         int syncType;
-        Cursor c = null;
-        String gid;
-        Node node;
+        Cursor c = null;                                           //数据库指针
+        String gid;                                                //GoogleID??
+        Node node;                                                 //Node包含Sync_Action的不同类型
 
-        mLocalDeleteIdMap.clear();
+        mLocalDeleteIdMap.clear();                                 //HashSet<Long>类型
 
         if (mCancelled) {
             return;
@@ -301,8 +317,8 @@ public class GTaskManager {
                     node = mGTaskHashMap.get(gid);
                     if (node != null) {
                         mGTaskHashMap.remove(gid);
-                        mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
-                        mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+                        mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));   //通过hashmap建立联系
+                        mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);   //通过hashmap建立联系
                         syncType = node.getSyncAction(c);
                     } else {
                         if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
@@ -327,14 +343,14 @@ public class GTaskManager {
         }
 
         // go through remaining items
-        Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
+        Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();   //Iterator迭代器
         while (iter.hasNext()) {
             Map.Entry<String, Node> entry = iter.next();
             node = entry.getValue();
             doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
         }
 
-        // mCancelled can be set by another thread, so we neet to check one by
+        // mCancelled can be set by another thread, so we neet to check one by    //thread----线程
         // one
         // clear local delete table
         if (!mCancelled) {
@@ -351,6 +367,11 @@ public class GTaskManager {
 
     }
 
+    /**
+     * 功能：
+     * @author TTS
+     * @throws NetworkFailureException
+     */
     private void syncFolder() throws NetworkFailureException {
         Cursor c = null;
         String gid;
@@ -394,7 +415,7 @@ public class GTaskManager {
         try {
             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
                     new String[] {
-                        String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
+                            String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
                     }, null);
             if (c != null) {
                 if (c.moveToNext()) {
@@ -476,6 +497,14 @@ public class GTaskManager {
             GTaskClient.getInstance().commitUpdate();
     }
 
+    /**
+     * 功能：syncType分类，addLocalNode，addRemoteNode，deleteNode，updateLocalNode，updateRemoteNode
+     * @author TTS
+     * @param syncType
+     * @param node
+     * @param c
+     * @throws NetworkFailureException
+     */
     private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -522,6 +551,12 @@ public class GTaskManager {
         }
     }
 
+    /**
+     * 功能：本地增加Node
+     * @author TTS
+     * @param node
+     * @throws NetworkFailureException
+     */
     private void addLocalNode(Node node) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -596,6 +631,15 @@ public class GTaskManager {
         updateRemoteMeta(node.getGid(), sqlNote);
     }
 
+    /**
+     * 功能：update本地node
+     * @author TTS
+     * @param node
+     * ----同步操作的基础数据类型
+     * @param c
+     * ----Cursor
+     * @throws NetworkFailureException
+     */
     private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -619,12 +663,22 @@ public class GTaskManager {
         updateRemoteMeta(node.getGid(), sqlNote);
     }
 
+    /**
+     * 功能：远程增加Node
+     * 需要updateRemoteMeta
+     * @author TTS
+     * @param node
+     * ----同步操作的基础数据类型
+     * @param c
+     * --Cursor
+     * @throws NetworkFailureException
+     */
     private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
         if (mCancelled) {
             return;
         }
 
-        SqlNote sqlNote = new SqlNote(mContext, c);
+        SqlNote sqlNote = new SqlNote(mContext, c);     //从本地mContext中获取内容
         Node n;
 
         // update remotely
@@ -634,11 +688,12 @@ public class GTaskManager {
 
             String parentGid = mNidToGid.get(sqlNote.getParentId());
             if (parentGid == null) {
-                Log.e(TAG, "cannot find task's parent tasklist");
+                Log.e(TAG, "cannot find task's parent tasklist");           //调试信息
                 throw new ActionFailureException("cannot add remote task");
             }
-            mGTaskListHashMap.get(parentGid).addChildTask(task);
+            mGTaskListHashMap.get(parentGid).addChildTask(task);            //在本地生成的GTaskList中增加子结点
 
+            //登录远程服务器，创建Task
             GTaskClient.getInstance().createTask(task);
             n = (Node) task;
 
@@ -656,6 +711,7 @@ public class GTaskManager {
             else
                 folderName += sqlNote.getSnippet();
 
+            //iterator迭代器，通过统一的接口迭代所有的map元素
             Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
             while (iter.hasNext()) {
                 Map.Entry<String, TaskList> entry = iter.next();
@@ -687,11 +743,20 @@ public class GTaskManager {
         sqlNote.resetLocalModified();
         sqlNote.commit(true);
 
-        // gid-id mapping
+        // gid-id mapping                                             //创建id间的映射
         mGidToNid.put(n.getGid(), sqlNote.getId());
         mNidToGid.put(sqlNote.getId(), n.getGid());
     }
 
+    /**
+     * 功能：更新远端的Node，包含meta更新(updateRemoteMeta)
+     * @author TTS
+     * @param node
+     * ----同步操作的基础数据类型
+     * @param c
+     *  --Cursor
+     * @throws NetworkFailureException
+     */
     private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
         if (mCancelled) {
             return;
@@ -701,7 +766,7 @@ public class GTaskManager {
 
         // update remotely
         node.setContentByLocalJSON(sqlNote.getContent());
-        GTaskClient.getInstance().addUpdateNode(node);
+        GTaskClient.getInstance().addUpdateNode(node);                                //GTaskClient用途为从本地登陆远端服务器
 
         // update meta
         updateRemoteMeta(node.getGid(), sqlNote);
@@ -710,15 +775,19 @@ public class GTaskManager {
         if (sqlNote.isNoteType()) {
             Task task = (Task) node;
             TaskList preParentList = task.getParent();
+            //preParentList为通过node获取的父节点列表
 
             String curParentGid = mNidToGid.get(sqlNote.getParentId());
+            //curParentGid为通过光标在数据库中找到sqlNote的mParentId，再通过mNidToGid由long类型转为String类型的Gid
+
             if (curParentGid == null) {
                 Log.e(TAG, "cannot find task's parent tasklist");
                 throw new ActionFailureException("cannot update remote task");
             }
             TaskList curParentList = mGTaskListHashMap.get(curParentGid);
+            //通过HashMap找到对应Gid的TaskList
 
-            if (preParentList != curParentList) {
+            if (preParentList != curParentList) {                                          //?????????????
                 preParentList.removeChildTask(task);
                 curParentList.addChildTask(task);
                 GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
@@ -727,9 +796,19 @@ public class GTaskManager {
 
         // clear local modified flag
         sqlNote.resetLocalModified();
+        //commit到本地数据库
         sqlNote.commit(true);
     }
 
+    /**
+     * 功能：升级远程meta。  meta---元数据----计算机文件系统管理数据---管理数据的数据。
+     * @author TTS
+     * @param gid
+     * ---GoogleID为String类型
+     * @param sqlNote
+     * ---同步前的数据库操作，故使用类SqlNote
+     * @throws NetworkFailureException
+     */
     private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
         if (sqlNote != null && sqlNote.isNoteType()) {
             MetaData metaData = mMetaHashMap.get(gid);
@@ -746,12 +825,18 @@ public class GTaskManager {
         }
     }
 
+    /**
+     * 功能：刷新本地，给sync的ID对应上最后更改过的对象
+     * @author TTS
+     * @return void
+     * @throws NetworkFailureException
+     */
     private void refreshLocalSyncId() throws NetworkFailureException {
         if (mCancelled) {
             return;
         }
 
-        // get the latest gtask list
+        // get the latest gtask list                                               //获取最近的（最晚的）gtask list
         mGTaskHashMap.clear();
         mGTaskListHashMap.clear();
         mMetaHashMap.clear();
@@ -762,16 +847,16 @@ public class GTaskManager {
             c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
                     "(type<>? AND parent_id<>?)", new String[] {
                             String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
-                    }, NoteColumns.TYPE + " DESC");
+                    }, NoteColumns.TYPE + " DESC");                                                 //query语句：五个参数，NoteColumns.TYPE + " DESC"-----为按类型递减顺序返回查询结果。new String[] {String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)}------为选择参数。"(type<>? AND parent_id<>?)"-------指明返回行过滤器。SqlNote.PROJECTION_NOTE--------应返回的数据列的名字。Notes.CONTENT_NOTE_URI--------contentProvider包含所有数据集所对应的uri
             if (c != null) {
                 while (c.moveToNext()) {
                     String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
                     Node node = mGTaskHashMap.get(gid);
                     if (node != null) {
                         mGTaskHashMap.remove(gid);
-                        ContentValues values = new ContentValues();
+                        ContentValues values = new ContentValues();                     //在ContentValues中创建键值对。准备通过contentResolver写入数据
                         values.put(NoteColumns.SYNC_ID, node.getLastModified());
-                        mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+                        mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,   //进行批量更改，选择参数为NULL，应该可以用insert替换，参数分别为表名和需要更新的value对象。
                                 c.getLong(SqlNote.ID_COLUMN)), values, null, null);
                     } else {
                         Log.e(TAG, "something is missed");
@@ -790,11 +875,20 @@ public class GTaskManager {
         }
     }
 
+    /**
+     * 功能：获取同步账号,mAccount.name
+     * @author TTS
+     * @return String
+     */
     public String getSyncAccount() {
         return GTaskClient.getInstance().getSyncAccount().name;
     }
 
+    /**
+     * 功能：取消同步，置mCancelled为true
+     * @author TTS
+     */
     public void cancelSync() {
         mCancelled = true;
     }
-}
+}